return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    SortedMultiset<String> set1 = ImmutableSortedMultiset.of("one");
    SortedMultiset<String> set2 = ImmutableSortedMultiset.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    List<String> list1 = ImmutableList.of("one");
    List<String> list2 = ImmutableList.of("two");
    new EqualsTester()
        .addEqualityGroup(list1, wrap(list1), wrap(list1))
        .addEqualityGroup(list2, wrap(list2))
        .testEquals();
  }

     */
    public DfsReferralDataImpl() {
        this.next = this;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.DfsReferralData#unwrap(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends DfsReferralData> T unwrap(final Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }
        throw new ClassCastException();

   * that tests equivalence using their lengths:
   *
   * {@snippet :
   * equiv.wrap("a").equals(equiv.wrap("b")) // true
   * equiv.wrap("a").equals(equiv.wrap("hello")) // false
   * }
   *
   * <p>Note in particular that an equivalence wrapper is never equal to the object it wraps.
   *
   * {@snippet :
   * equiv.wrap(obj).equals(obj) // always false
   * }
   *
   * @since 10.0
   */

        when(mockContext.getTransportPool()).thenReturn(mockTransportPool);
        when(mockTransportPool.getSmbTransport(any(), anyString(), anyInt(), anyBoolean(), anyBoolean())).thenReturn(mockTransport);
        when(mockTransport.unwrap(any())).thenReturn(mockTransport);
        when(mockTransport.getDfsReferrals(any(), anyString(), anyString(), anyString(), anyInt())).thenReturn(null);
        assertNull(dfsResolver.getDc(mockContext, "anyDomain"));
    }

        if (value == null) {
            return true;
        }

        final HibernateConstraintValidatorContext hibernateContext = context.unwrap(HibernateConstraintValidatorContext.class);
        hibernateContext.disableDefaultConstraintViolation();
        hibernateContext.addMessageParameter("min", min)
                .addMessageParameter("max", max)

    assertTrue(okSource.wasStreamClosed());
  }

  public void testConcat() throws IOException {
    ByteSource b1 = ByteSource.wrap(new byte[] {0, 1, 2, 3});
    ByteSource b2 = ByteSource.wrap(new byte[0]);
    ByteSource b3 = ByteSource.wrap(new byte[] {4, 5});

    byte[] expected = {0, 1, 2, 3, 4, 5};

    assertArrayEquals(expected, ByteSource.concat(ImmutableList.of(b1, b2, b3)).read());

.md-footer-meta {
  padding-bottom: 2em;
}

.md-footer-meta .md-social {
  padding-right: 4rem;
}

.user-list {
  display: flex;
  flex-wrap: wrap;
  margin-bottom: 2rem;
}

.user-list-center {
  justify-content: space-evenly;
}

.user {
  margin: 1em;
  min-width: 7em;
}

.user .avatar-wrapper {
  width: 80px;

     *
     * @param process the system process to wrap
     */
    public JobProcess(final Process process) {
        this(process, InputStreamThread.MAX_BUFFER_SIZE, null);
    }

    /**
     * Constructs a new JobProcess with the specified process, buffer size, and output callback.
     *
     * @param process the system process to wrap
     * @param bufferSize the buffer size for reading process output

        }

        // MS-SMB2 specifies little-endian byte ordering for GUID components
        // Convert from little-endian wire format to Java UUID
        ByteBuffer bb = ByteBuffer.wrap(bytes).order(java.nio.ByteOrder.LITTLE_ENDIAN);

        // Read GUID components in little-endian order
        int data1 = bb.getInt(); // first 4 bytes (little-endian)