assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.<Integer>of(), result);
  }

  public void testLeastOfIterator_empty_0() {
    List<Integer> result = numberOrdering.leastOf(Iterators.<Integer>emptyIterator(), 0);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);

            return null;
        } else if (o instanceof BigDecimal) {
            return (BigDecimal) o;
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {
                return new BigDecimal(new SimpleDateFormat(pattern).format(o));
            }
            return new BigDecimal(Long.toString(((java.util.Date) o).getTime()));
        } else if (o instanceof String) {
            final String s = (String) o;

        try {
            final Class<?> cls = targetOrClass instanceof Class<?> ? (Class<?>) targetOrClass : targetOrClass.getClass();
            Method m = cls.getDeclaredMethod(methodName, paramTypes);
            m.setAccessible(true);
            return m.invoke(targetOrClass instanceof Class<?> ? null : targetOrClass, args);

        }

        @Test
        @DisplayName("Should extend jcifs.smb1.http.Handler")
        void testInheritance() {
            // Then
            assertTrue(handler instanceof jcifs.smb1.http.Handler);
            assertTrue(handler instanceof URLStreamHandler);
        }
    }

    @Nested
    @DisplayName("Default Port Tests")
    class DefaultPortTests {

        @Test

        if (e.getCause() instanceof MultipleArtifactsNotFoundException) {
            return true;
        }
        return e.getCause() instanceof org.eclipse.aether.resolution.ArtifactResolutionException
                && e.getCause().getCause() instanceof ArtifactNotFoundException;
    }

    private boolean isNonTransferablePom(Exception e) {
        if (e.getCause() instanceof ArtifactResolutionException) {

    void testInheritance() {
        response = new Smb2QueryInfoResponse(mockConfig, (byte) 1, (byte) 2);
        assertTrue(response instanceof ServerMessageBlock2Response);
        assertTrue(response instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Test OVERHEAD constant value")
    void testOverheadConstant() {

            return null;
        }
        if (src.getClass() == Date.class) {
            return (Date) src;
        }
        if (src instanceof Date) {
            return new Date(((Date) src).getTime());
        }
        if (src instanceof Calendar) {
            return new Date(((Calendar) src).getTimeInMillis());
        }
        final String str = src.toString();
        if (isEmpty(str)) {

            if (metadata instanceof ProjectArtifactMetadata projectArtifactMetadata) {
                org.eclipse.aether.artifact.Artifact pomArtifact = new SubArtifact(mainArtifact, "", "pom");
                pomArtifact = pomArtifact.setFile(projectArtifactMetadata.getFile());
                request.addArtifact(pomArtifact);
            } else if (metadata instanceof SnapshotArtifactRepositoryMetadata

        assertEquals(20, bytesRead, "Should read 20 bytes");
        assertNotNull(response.info, "Info object should not be null");
        assertTrue(response.info instanceof Trans2QueryFSInformationResponse.SmbInfoAllocation, "Info should be of type SmbInfoAllocation");

        Trans2QueryFSInformationResponse.SmbInfoAllocation info = (Trans2QueryFSInformationResponse.SmbInfoAllocation) response.info;

     *
     * 1) An interface I extending Comparable<I> so that the created array is of
     * an interface type. 2) An instance of a class implementing that interface
     * so that we can pass non-null instances of the interface.
     *
     * (Currently it's safe to pass instances for which compareTo() always
     * returns 0, but if we had a SingletonImmutableSortedSet, this might no
     * longer be the case.)
     *