codenameone
diff --git a/‎maven/core-unittests/src/test/java/com/codename1/charts/util/ColorUtilTest.java‎
Lines changed: 52 additions & 0 deletions b/‎maven/core-unittests/src/test/java/com/codename1/charts/util/ColorUtilTest.java‎
Lines changed: 52 additions & 0 deletions
diff --git a/‎maven/core-unittests/src/test/java/com/codename1/contacts/AddressTest.java‎
Lines changed: 28 additions & 0 deletions b/‎maven/core-unittests/src/test/java/com/codename1/contacts/AddressTest.java‎
Lines changed: 28 additions & 0 deletions
diff --git a/‎maven/core-unittests/src/test/java/com/codename1/io/NetworkManagerTest.java‎
Lines changed: 77 additions & 5 deletions b/‎maven/core-unittests/src/test/java/com/codename1/io/NetworkManagerTest.java‎
Lines changed: 77 additions & 5 deletions
diff --git a/‎maven/core-unittests/src/test/java/com/codename1/io/SocketTest.java‎
Lines changed: 35 additions & 0 deletions b/‎maven/core-unittests/src/test/java/com/codename1/io/SocketTest.java‎
Lines changed: 35 additions & 0 deletions
@@ -1,6 +1,9 @@
 package com.codename1.charts.util;
 
 import org.junit.jupiter.api.Test;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -29,4 +32,53 @@ void predefinedColorsMatchRgbValues() {
         assertEquals(ColorUtil.rgb(0, 255, 0), ColorUtil.GREEN);
         assertEquals(ColorUtil.rgb(255, 255, 0), ColorUtil.YELLOW);
     }
+
+    @Test
+    void testTransparentInnerClass() throws Exception {
+        // Access ColorUtil.IColor (private static)
+        Class<?> iColorClass = null;
+        for (Class<?> cls : ColorUtil.class.getDeclaredClasses()) {
+            if (cls.getSimpleName().equals("IColor")) {
+                iColorClass = cls;
+                break;
+            }
+        }
+        assertNotNull(iColorClass, "IColor inner class not found");
+
+        // Access ColorUtil.IColor.Transparent (public static)
+        Class<?> transparentClass = null;
+        for (Class<?> cls : iColorClass.getDeclaredClasses()) {
+            if (cls.getSimpleName().equals("Transparent")) {
+                transparentClass = cls;
+                break;
+            }
+        }
+        assertNotNull(transparentClass, "Transparent inner class not found");
+
+        // Instantiate Transparent via reflection (constructor is public but class is inside private class, so usually okay if static?)
+        // Actually since Transparent is public static inside private static, it is accessible if we know the name?
+        // No, direct access via source fails if outer is private.
+
+        Constructor<?> ctor = transparentClass.getConstructor(int.class, int.class, int.class);
+        Object transparentObj = ctor.newInstance(255, 0, 0); // Red
+
+        // Check fields via reflection
+        // IColor fields: alpha, red, green, blue
+        Field alphaField = iColorClass.getDeclaredField("alpha");
+        Field redField = iColorClass.getDeclaredField("red");
+        Field greenField = iColorClass.getDeclaredField("green");
+        Field blueField = iColorClass.getDeclaredField("blue");
+
+        // Transparent constructor sets alpha to 0
+        assertEquals(0, alphaField.getInt(transparentObj));
+        assertEquals(255, redField.getInt(transparentObj));
+        assertEquals(0, greenField.getInt(transparentObj));
+        assertEquals(0, blueField.getInt(transparentObj));
+
+        // Check static constants like Transparent.Red
+        Field redConstant = transparentClass.getField("Red");
+        Object redObj = redConstant.get(null);
+        assertEquals(0, alphaField.getInt(redObj));
+        assertEquals(255, redField.getInt(redObj));
+    }
 }
@@ -0,0 +1,28 @@
+package com.codename1.contacts;
+
+import com.codename1.junit.FormTest;
+import com.codename1.junit.UITestBase;
+import org.junit.jupiter.api.Assertions;
+
+public class AddressTest extends UITestBase {
+
+    @FormTest
+    public void testAddressPOJO() {
+        Address addr = new Address();
+
+        addr.setStreetAddress("123 Main St");
+        Assertions.assertEquals("123 Main St", addr.getStreetAddress());
+
+        addr.setLocality("City");
+        Assertions.assertEquals("City", addr.getLocality());
+
+        addr.setRegion("State");
+        Assertions.assertEquals("State", addr.getRegion());
+
+        addr.setPostalCode("12345");
+        Assertions.assertEquals("12345", addr.getPostalCode());
+
+        addr.setCountry("Country");
+        Assertions.assertEquals("Country", addr.getCountry());
+    }
+}
@@ -7,35 +7,41 @@
 import com.codename1.ui.events.ActionListener;
 import com.codename1.io.Storage;
 import com.codename1.io.Util;
+import com.codename1.util.AsyncResource;
+import java.io.InputStream;
+import java.io.IOException;
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Vector;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
-class NetworkManagerTest {
+
+class NetworkManagerTest extends com.codename1.junit.UITestBase {
     private NetworkManager manager;
-    private TestCodenameOneImplementation implementation;
 
     @BeforeEach
     void setUp() throws Exception {
+        super.setUpDisplay();
         Storage.setStorageInstance(null);
-        implementation = new TestCodenameOneImplementation(true);
-        Util.setImplementation(implementation);
         manager = NetworkManager.getInstance();
         resetManagerState();
     }
 
     @AfterEach
     void tearDown() throws Exception {
         resetManagerState();
-        Util.setImplementation(null);
         Storage.setStorageInstance(null);
+        implementation.clearNetworkMocks();
+        super.tearDownDisplay();
     }
 
     @Test
@@ -165,6 +171,72 @@ void apDelegatesToImplementation() {
         assertEquals("WiFi", manager.getAPName("wifi"));
     }
 
+    @FormTest
+    void testAddToQueueAsync() throws Exception {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<ConnectionRequest> result = new AtomicReference<>();
+        final AtomicReference<Throwable> error = new AtomicReference<>();
+
+        ConnectionRequest req = new ConnectionRequest() {
+            @Override
+            protected void readResponse(InputStream input) throws IOException {
+                // do nothing
+            }
+        };
+        req.setUrl("http://example.com/async");
+        req.setPost(false);
+
+        TestCodenameOneImplementation.getInstance().addNetworkMockResponse("http://example.com/async", 200, "OK", new byte[0]);
+
+        AsyncResource<ConnectionRequest> res = manager.addToQueueAsync(req);
+        res.ready(r -> {
+            result.set(r);
+            latch.countDown();
+        });
+        res.except(e -> {
+            error.set(e);
+            latch.countDown();
+        });
+
+        try {
+            waitFor(latch, 2000);
+        } catch (AssertionError e) {
+            // Retry with explicit loop just in case waitFor is not behaving as expected with threads
+            long start = System.currentTimeMillis();
+            while (latch.getCount() > 0) {
+                if (System.currentTimeMillis() - start > 2000) {
+                    throw new AssertionError("Timed out waiting for async request");
+                }
+                com.codename1.ui.DisplayTest.flushEdt();
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException ex) {}
+            }
+        }
+
+        assertNull(error.get());
+        assertSame(req, result.get());
+        assertTrue(req.complete);
+    }
+
+    @FormTest
+    void testAddToQueueAndWait() throws Exception {
+        final ConnectionRequest req = new ConnectionRequest() {
+            @Override
+            protected void readResponse(InputStream input) throws IOException {
+                // do nothing
+            }
+        };
+        req.setUrl("http://example.com/wait");
+        req.setPost(false);
+
+        TestCodenameOneImplementation.getInstance().addNetworkMockResponse("http://example.com/wait", 200, "OK", new byte[0]);
+
+        manager.addToQueueAndWait(req);
+
+        assertTrue(req.complete);
+    }
+
     private Vector getPendingQueue() throws Exception {
         Field pendingField = NetworkManager.class.getDeclaredField("pending");
         pendingField.setAccessible(true);
 
@@ -170,4 +170,39 @@ void getHostOrIpDelegatesToImplementation() {
         implementation.setHostOrIP("device.local");
         assertEquals("device.local", Socket.getHostOrIP());
     }
+
+    public static class MockSocketConnection extends SocketConnection {
+        public static CountDownLatch latch;
+        public static AtomicInteger successCount = new AtomicInteger();
+
+        public MockSocketConnection() {
+        }
+
+        @Override
+        public void connectionEstablished(InputStream is, OutputStream os) {
+            successCount.incrementAndGet();
+            if (latch != null) latch.countDown();
+        }
+
+        @Override
+        public void connectionError(int errorCode, String message) {
+        }
+    }
+
+    @EdtTest
+    void testListen() throws Exception {
+        int port = 9999;
+        MockSocketConnection.latch = new CountDownLatch(1);
+        MockSocketConnection.successCount.set(0);
+
+        Socket.StopListening listener = Socket.listen(port, MockSocketConnection.class);
+
+        TestSocket mockSocket = new TestSocket("localhost", port);
+        implementation.simulateIncomingConnection(port, mockSocket);
+
+        assertTrue(MockSocketConnection.latch.await(2, TimeUnit.SECONDS));
+        assertEquals(1, MockSocketConnection.successCount.get());
+
+        listener.stop();
+    }
 }