String message = "Script engine test error";
        ScriptEngineException exception = new ScriptEngineException(message);

        String result = exception.toString();
        assertNotNull(result);
        assertTrue(result.contains("ScriptEngineException"));
        assertTrue(result.contains(message));
    }

    public void test_withComplexCauseChain() {
        // Test with a chain of exceptions

    @ValueSource(booleans = { true, false })
    void isInUse_variants(boolean inUse) {
        when(session.isInUse()).thenReturn(inUse);

        boolean result = session.isInUse();

        assertEquals(inUse, result);
        verify(session, times(1)).isInUse();
    }

    // Happy path + edge: getSessionKey returns bytes, empty and null
    @Test

        int result = NtlmMessage.readULong(a, 0);
        assertEquals(0x04030201, result, "ULong should be little‑endian");
    }

    @Test
    @DisplayName("readUShort correctly interprets little endian")
    void testReadUShort() {
        byte[] a = new byte[] { (byte) 0xAA, (byte) 0xBB };
        int result = NtlmMessage.readUShort(a, 0);

    Iterables.addAll(multiset, elements);
    return multiset;
  }

  public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements, Class<E> type) {
    EnumMultiset<E> result = create(type);
    Iterables.addAll(result, elements);
    return result;
  }

  /** Creates an empty {@code EnumMultiset}. */
  private EnumMultiset(EnumMap<E, Count> map) {
    super(map);
  }

            return true;
        }
        return false;
    }

    /**
     * Builds and populates search form parameters including results per page,
     * label filtering, and sort order based on user preferences and configuration.
     *
     * @param form the search form to populate with parameters
     */

        final String result = getAsQuery(conditions);
        assertTrue(result.contains("search term"));
        assertTrue(result.contains("\"exact phrase\""));
        assertTrue(result.contains("(word1 OR word2)"));
        assertTrue(result.contains("NOT exclude"));
        assertTrue(result.contains("filetype:\"pdf\""));
        assertTrue(result.contains("site:example.com"));
    }

            // Combine IV and ciphertext
            byte[] result = new byte[GCM_IV_SIZE + ciphertext.length];
            System.arraycopy(iv, 0, result, 0, GCM_IV_SIZE);
            System.arraycopy(ciphertext, 0, result, GCM_IV_SIZE, ciphertext.length);

            return result;

        } finally {
            // Securely wipe plaintext bytes - guaranteed by try-finally

        assertFalse(result.contains("\u0001"));
    }

    @Test
    void toString_withoutScope_shouldNotIncludeScope() {
        Name name = new Name(mockConfig, "TEST", 0x20, null);
        name.scope = null;

        String result = name.toString();
        assertTrue(result.contains("TEST"));
        assertTrue(result.contains("<20>"));
        assertFalse(result.contains("."));
    }

					Bucket: bktName,
					Queued: time.Now(),
				})
			}
		}
	}

	result := make([]BucketInfo, 0, len(resultMap))
	for _, bi := range resultMap {
		result = append(result, bi)
	}

	sort.Slice(result, func(i, j int) bool {
		return result[i].Name < result[j].Name
	})

	return result, nil
}

// GetBucketInfo returns bucket stat info about bucket on disk across all peers

    Iterable<Integer> result = Iterables.concat(input);
    assertEquals(asList(1, 4), newArrayList(result));

    // Now change the inputs and see result dynamically change as well

    list1.add(2);
    List<Integer> list3 = newArrayList(3);
    input.add(1, list3);

    assertEquals(asList(1, 2, 3, 4), newArrayList(result));
    assertEquals("[1, 2, 3, 4]", result.toString());
  }