ResultOffsetExceededException exception3 = new ResultOffsetExceededException("Third instance");

        assertNotSame(exception1, exception2);
        assertNotSame(exception2, exception3);
        assertNotSame(exception1, exception3);

        assertEquals("First instance", exception1.getMessage());
        assertEquals("Second instance", exception2.getMessage());

        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: second acquire does not call tree.acquire again
        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: first release does not release yet (usage -> 1)
        c.release();
        verify(tree, never()).release();

        // Act: second release (usage -> 0) releases the tree
        c.release();

        // Then
        assertNotNull(resource1, "First resource should be created");
        assertNotNull(resource2, "Second resource should be created");
        assertNotNull(pipe1, "First pipe should be created");
        assertNotNull(pipe2, "Second pipe should be created");

        assertNotSame(resource1, resource2, "Different resources should be different instances");

					}
				}()
			}
		}(index)
	}

	time.Sleep(duration)
	xioutil.SafeClose(r.eof)
	wg.Wait()
	for globalNetPerfRX.ActiveConnections() != 0 {
		time.Sleep(time.Second)
	}
	rx := float64(globalNetPerfRX.RXSample)
	delta := globalNetPerfRX.firstToDisconnect.Sub(globalNetPerfRX.lastToConnect)
	if delta < 0 {
		rx = 0
		errStr = "network disconnection issues detected"
	}

  }

  public void testMapping() {
    Map<Character, String> map =
        ImmutableMap.of(
            '\0', "zero",
            'a', "first",
            'b', "second",
            'z', "last",
            '\uFFFF', "biggest");
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    char[][] replacementArray = fem.getReplacementArray();

    assertTrue(tokL.isSupertypeOf(StringList.class.getGenericInterfaces()[0]));

    @SuppressWarnings("rawtypes") // Trying to test raw class
    TypeToken<Second> tokS = new TypeToken<Second>() {};
    assertTrue(tokS.isSupertypeOf(Second.class));
    assertTrue(tokS.isSupertypeOf(Third.class.getGenericSuperclass()));
  }

  public void testAssignableArrayToClass() {

            byte[] buffer1 = new byte[1024];
            int bytesRead1 = stream1.read(buffer1);
            assertEquals(testContent, new String(buffer1, 0, bytesRead1, "UTF-8"));
        }

        // Second read - should work independently
        try (InputStream stream2 = cache.getInputStream()) {
            byte[] buffer2 = new byte[1024];
            int bytesRead2 = stream2.read(buffer2);

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build();

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build();

                    response.setExtendedSecurity(true);
                    request.setUid(getUid());
                    setUid(0);

                    try {
                        trans.send(request, response);
                    } catch (SmbAuthException sae) {
                        throw sae;
                    } catch (SmbException se) {

    /**
     * Determines which of the specified versions of an artifact to use when there are conflicting declarations.
     *
     * @param node1 the first artifact declaration
     * @param node2 the second artifact declaration
     * @return the artifact declaration to use: <code>node1</code>; <code>node2</code>; or <code>null</code>if
     *         this conflict cannot be resolved
     * @since 3.0
     */