Encdec.enc_uint32le(0xFFFF + 1, buffer, 8);

        ndrBuffer.setIndex(0);
        NdrException thrown = assertThrows(NdrException.class, () -> {
            ndrBuffer.dec_ndr_string();
        });
        assertEquals(NdrException.INVALID_CONFORMANCE, thrown.getMessage());
    }

    @Test
    void testEncNdrReferent() {
        Object obj1 = new Object();

                throw new RuntimeException("I'm a misbehaving implementation");
              }
            }.toString())
        .matches(
            "[^\\[]+\\[status=PENDING, info=\\[Exception thrown from implementation: "
                + "class java.lang.RuntimeException\\]\\]");
  }

  public void testCompletionFinishesWithDone() {
    ExecutorService executor = newFixedThreadPool(10);

    /** Constructor for use by subclasses. */
    public StandardKeySet() {
      super(ForwardingSortedMap.this);
    }
  }

  // unsafe, but worst case is a CCE or NPE is thrown, which callers will be expecting
  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @Nullable Comparator<?> comparator, @Nullable Object o1, @Nullable Object o2) {
    if (comparator == null) {

    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**
   * Thrown if the test tries to invoke a constructor or static factory method but failed because
   * the dummy value of a constructor or method parameter is unknown.
   */
  @VisibleForTesting

    threadFailure.compareAndSet(null, t);
  }

  /**
   * Extra checks that get done for all test cases.
   *
   * <p>Triggers test case failure if any thread assertions have failed, by rethrowing, in the test
   * harness thread, any exception recorded earlier by threadRecordFailure.
   *
   * <p>Triggers test case failure if interrupted status is set in the main thread.
   */
  @Override

        File unregisteredObject = new File("/tmp/test");

        try {
            serializer.fromObjectToBinary(unregisteredObject);
            fail("Should have thrown an exception for unregistered class");
        } catch (Exception e) {
            // Find the root cause - it should be related to unregistered class
            Throwable rootCause = e;

        // When/Then: Should throw last exception
        IOException thrown = assertThrows(IOException.class, () -> poolSpy.getSmbTransport(ctx, "failing.server", 445, false, false));
        assertSame(secondException, thrown);

        // Verify fail counts incremented
        assertEquals(1, pool.failCounts.get("10.0.0.1"));

 *
 * <p>The tested methods and constructors are invoked -- each time with one parameter being null and
 * the rest not null -- and the test fails if no expected exception is thrown. {@code
 * NullPointerTester} uses best effort to pick non-null default values for many common JDK and Guava
 * types, and also for interfaces and public classes that have public parameter-less constructors.

            } else {
              haveBeenCalled = true;
              throw sneakyThrow(new SomeCheckedException());
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out
    assertThrows(SomeCheckedException.class, iter::hasNext);
    // But the second time, AbstractIterator itself throws an ISE
    assertThrows(IllegalStateException.class, iter::hasNext);
  }

            } else {
              haveBeenCalled = true;
              throw sneakyThrow(new SomeCheckedException());
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out
    assertThrows(SomeCheckedException.class, iter::hasNext);
    // But the second time, AbstractIterator itself throws an ISE
    assertThrows(IllegalStateException.class, iter::hasNext);
  }