void testJoinWithStringBuilder() {
        StringBuilder sb1 = new StringBuilder("first");
        StringBuilder sb2 = new StringBuilder("second");
        String result = StringUtil.join(",", sb1, sb2);
        assertEquals("first,second", result);
    }

    @Test
    @DisplayName("Should handle StringBuffer as CharSequence")
    void testJoinWithStringBuffer() {

      if (first == null) {
        actionWhenFirstParamIsNull.act();
      }
      if (second == null) {
        actionWhenSecondParamIsNull.act();
      }
    }

    /** Two-arg method with no Nullable params. */
    public void normalNormal(String first, Integer second) {
      reactToNullParameters(first, second);
    }

   * @param second the second array of elements to concatenate
   * @param type the component type of the returned array
   */
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] concat(
      T[] first, T[] second, Class<@NonNull T> type) {
    T[] result = newArray(type, first.length + second.length);
    arraycopy(first, 0, result, 0, first.length);

        InvertibleCryptographer first = securityResourceProvider.providePrimaryInvertibleCryptographer();
        InvertibleCryptographer second = securityResourceProvider.providePrimaryInvertibleCryptographer();

        assertNotNull(first);
        assertNotNull(second);
        assertSame(first, second);
        assertSame(invertibleCryptographer, first);
    }

    public void test_providePrimaryInvertibleCryptographer_consistency() {

	"compress/gzip"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math/rand"
	"net/url"
	"time"

	"github.com/minio/madmin-go/v3"
)

var callhomeLeaderLockTimeout = newDynamicTimeout(30*time.Second, 10*time.Second)

// initCallhome will start the callhome task in the background.
func initCallhome(ctx context.Context, objAPI ObjectLayer) {
	if !globalCallhomeConfig.Enabled() {
		return
	}

	go func() {

        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");
        assertEquals((byte) 0xA2, encoded[2], "First byte of second character");
        assertEquals((byte) 0x00, encoded[3], "Second byte of second character");
    }

    @Test
    public void testAsciiEncoding() throws Exception {

    public int compare(@Nullable String first, @Nullable String second) {
      if (first == second) {
        return 0;
      } else if (first == null) {
        return -1;
      } else if (second == null) {
        return 1;
      } else if (first.length() != second.length()) {
        return first.length() - second.length();
      } else {
        return first.compareTo(second);
      }
    }
  }

        ChannelInfo second = loadBalancer.selectChannel(mockMessage);

        assertNotNull(first);
        assertNotNull(second);
        // Due to round-robin, should get different channels or same order
        assertTrue(Arrays.asList(channel1, channel2).contains(first));
        assertTrue(Arrays.asList(channel1, channel2).contains(second));
    }

    @Test

        ByteBuffer buffer = ByteBuffer.allocate(200);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // First notification with nextEntryOffset pointing to second
        int secondOffset = 48;
        buffer.putInt(secondOffset); // nextEntryOffset to second entry
        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        String fileName1 = "first.txt";
        byte[] fileNameBytes1 = fileName1.getBytes("UTF-16LE");

    lock2 = factory2.newReentrantLock(MyOrder.SECOND);
    lock3 = factory2.newReentrantLock(MyOrder.THIRD);

    CycleDetectingLockFactory.WithExplicitOrdering<OtherOrder> factory3 =
        newInstanceWithExplicitOrdering(OtherOrder.class, Policies.THROW);
    lock01 = factory3.newReentrantLock(OtherOrder.FIRST);
    lock02 = factory3.newReentrantLock(OtherOrder.SECOND);
    lock03 = factory3.newReentrantLock(OtherOrder.THIRD);
  }