/** Ending minute of the interval */
        protected int toMinutes;

        /** Delay in milliseconds to apply during this interval */
        protected long delay;

        /** Array of days when this rule applies (1=Sunday, 7=Saturday) */
        protected int[] days;

        /** Flag indicating if the interval spans across midnight */
        protected boolean reverse;

        /**

        paramMap.put("value", null);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("Value is: null", result);
    }

    // Test evaluate method with array as parameter
    @Test
    public void test_evaluate_withArrayParameter() {
        String template = "Items: ${items}";
        Map<String, Object> paramMap = new HashMap<>();

        for (int i = 0; i < fieldCount; i++) {
            fields[i] = "field" + i;
        }
        queryFieldConfig.setSearchFields(fields);

        // Test field at the end (worst case for array lookup, but same for Set)
        String testField = "field999";

        // Warm up
        for (int i = 0; i < 100; i++) {
            queryCommand.isSearchField(testField);
        }

    }

    /**
     * Test getMessageByDcerpcError() with an error code larger than any known.
     * The binary search implementation has a bug where it accesses array out of bounds.
     */
    @Test
    void testGetMessageByDcerpcError_largerThanAny() {
        int unknownCode = 0x7FFFFFFF; // Max int value

        assertEquals(40, response.dataOffset);
        assertEquals(0, response.dataDisplacement);
        assertEquals(1, response.setupCount);
    }

    // Helper method to write a 4-byte integer to a byte array.
    private void writeInt4(int val, byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) val;
        dst[dstIndex + 1] = (byte) (val >> 8);
        dst[dstIndex + 2] = (byte) (val >> 16);

  "$ref": "#/definitions/Changelog",
  "definitions": {
    "Changelog": {
      "type": "object",
      "properties": {
        "pr": {
          "type": "integer"
        },
        "issues": {
          "type": "array",
          "items": {
            "type": "integer"
          }
        },
        "area": {
          "type": "string",
          "enum": [
            "Aggregations",
            "Allocation",

            }
            return null;
        }

        /**
         * Creates a list from an array of configuration ID values.
         *
         * @param values array of configuration ID strings
         * @return list containing all values from the array
         */
        private static List<String> createConfigIdList(final String[] values) {

        assert i == body.length;
        return body;
    }

    /**
     * Build a CREATE response body with a single, unrecognized create context.
     * The parser should iterate it but produce an empty contexts array.
     */
    private static byte[] buildCreateBodyWithContext(byte[] fileId, int contextStartOffsetFromHeader) {
        // Base body part size (up to and including CreateContextsLength)

	if err != nil {
		t.Fatal(err)
	}
	js, err = dec.DecodeAll(js, nil)
	if err != nil {
		t.Fatal(err)
	}

	return js
}

var testCases = []struct {
	name  string
	array bool
}{
	{
		name: "parking-citations-10",
	},
}

func TestNDJSON(t *testing.T) {
	if !simdjson.SupportedCPU() {
		t.Skip("Unsupported cpu")
	}

	for _, tt := range testCases {

            buffer.putLong(524288L); // Actual free allocation units (512K)
            buffer.putInt(8); // Sectors per allocation unit
            buffer.putInt(512); // Bytes per sector
            byte[] bufferArray = buffer.array();

            // When
            int bytesConsumed = fileFsFullSizeInfo.decode(bufferArray, 0, bufferArray.length);

            // Then
            assertEquals(32, bytesConsumed);