modules/cldc-compact/src/test/java/lang/TestVMInterrupt.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package lang;
  11
  12 import net.multiphasicapps.tac.TestRunnable;
  13
  14 /**
  15  * Tests interrupted, monitors, and threads as well.
  16  *
  17  * @since 2018/11/20
  18  */
  19 public class TestVMInterrupt
  20         extends TestRunnable
  21 {
  22         /** The object to lock on. */
  23         protected final Object lock =
  24                 new Object();
  25
  26         /** The order of things, is a check for locks. */
  27         protected volatile int order;
  28
  29         /**
  30          * {@inheritDoc}
  31          * @since 2018/11/20
  32          */
  33         @Override
  34         public void test()
  35         {
  36                 Thread self = Thread.currentThread();
  37
  38                 // Note
  39                 this.secondary("a-before-lock", order++);
  40
  41                 // Lock on this object
  42                 synchronized (this.lock)
  43                 {
  44                         // Note
  45                         this.secondary("a-after-lock", order++);
  46
  47                         // Setup thread to run
  48                         Thread runner = new Thread(new __Runner__(
  49                                 self), "VMInterruptChild");
  50                         runner.start();
  51
  52                         // Note
  53                         this.secondary("a-thread-created", order++);
  54                         this.secondary("a-before-wait", self.isInterrupted());
  55
  56                         // Wait for a notification
  57                         try
  58                         {
  59                                 this.lock.wait(20000);
  60
  61                                 // Note
  62                                 this.secondary("a-was-not-interrupted", order++);
  63                         }
  64                         catch (InterruptedException e)
  65                         {
  66                                 // Note
  67                                 this.secondary("a-was-interrupted", order++);
  68                         }
  69
  70                         // Note
  71                         this.secondary("a-after-wait", self.isInterrupted());
  72                 }
  73
  74                 // Note
  75                 this.secondary("a-done", order++);
  76         }
  77
  78         /**
  79          * Performs the second part of the test run.
  80          *
  81          * @since 2018/11/20
  82          */
  83         final class __Runner__
  84                 implements Runnable
  85         {
  86                 /** The thread to signal. */
  87                 protected final Thread signal;
  88
  89                 /**
  90                  * Initializes the runner.
  91                  *
  92                  * @param __t The thread to signal.
  93                  * @throws NullPointerException On null arguments.
  94                  * @since 2018/11/20
  95                  */
  96                 public __Runner__(Thread __t)
  97                         throws NullPointerException
  98                 {
  99                         if (__t == null)
 100                                 throw new NullPointerException("NARG");
 101
 102                         this.signal = __t;
 103                 }
 104
 105                 /**
 106                  * {@inheritDoc}
 107                  * @since 2018/11/20
 108                  */
 109                 @Override
 110                 public void run()
 111                 {
 112                         // Lock
 113                         synchronized (TestVMInterrupt.this.lock)
 114                         {
 115                                 // Note
 116                                 TestVMInterrupt.this.secondary("b-in-lock",
 117                                         TestVMInterrupt.this.order++);
 118
 119                                 // Interrupt A
 120                                 this.signal.interrupt();
 121
 122                                 // Note
 123                                 TestVMInterrupt.this.secondary("b-interrupt-a",
 124                                         TestVMInterrupt.this.order++);
 125
 126                                 // Sleep for a bit
 127                                 try
 128                                 {
 129                                         // Note
 130                                         TestVMInterrupt.this.secondary("b-dosleep",
 131                                                 TestVMInterrupt.this.order++);
 132
 133                                         // Sleep for a bit longer than the main thread
 134                                         Thread.sleep(3000);
 135
 136                                         // Note
 137                                         TestVMInterrupt.this.secondary("b-sleepdone",
 138                                                 TestVMInterrupt.this.order++);
 139                                 }
 140                                 catch (InterruptedException e)
 141                                 {
 142                                         TestVMInterrupt.this.secondary("b-interrupted",
 143                                                 TestVMInterrupt.this.order++);
 144                                 }
 145
 146                                 // About to unlock
 147                                 TestVMInterrupt.this.secondary("b-about-to-unlock",
 148                                         TestVMInterrupt.this.order++);
 149                         }
 150                 }
 151         }
 152 }
 153