}

    /**
     * Test rule order preservation
     */
    public void test_ruleOrderPreservation() {
        TestRule rule1 = new TestRule("rule1", false);
        TestRule rule2 = new TestRule("rule2", true);
        TestRule rule3 = new TestRule("rule3", false);
        TestRule rule4 = new TestRule("rule4", true);

        ruleManager.addRule(rule1);
        ruleManager.addRule(rule2);
        ruleManager.addRule(rule3);

        TestResponseProcessor sharedProcessor = new TestResponseProcessor("shared");

        TestRule rule1 = new TestRule("rule1", sharedProcessor, true);
        TestRule rule2 = new TestRule("rule2", sharedProcessor, false);
        TestRule rule3 = new TestRule("rule3", sharedProcessor, true);

        // Same processor instance
        assertSame(sharedProcessor, rule1.getResponseProcessor());

        // Initial state
        assertNull(testRule.getRuleId());

        // Set rule ID
        testRule.setRuleId("testRule1");
        assertEquals("testRule1", testRule.getRuleId());

        // Change rule ID
        testRule.setRuleId("changedRule");
        assertEquals("changedRule", testRule.getRuleId());

        // Set null rule ID
        testRule.setRuleId(null);

}

// validates the credential fields against the expected credential.
func validateCredentialfields(t *testing.T, testNum int, expectedCredentials credentialHeader, actualCredential credentialHeader) {
	if expectedCredentials.accessKey != actualCredential.accessKey {
		t.Errorf("Test %d: AccessKey mismatch: Expected \"%s\", got \"%s\"", testNum, expectedCredentials.accessKey, actualCredential.accessKey)
	}

				"Resource": ["arn:minio:kms:::non-matching-key-name"] }`,

			wantStatusCode: http.StatusForbidden,
			wantResp:       []string{"AccessDenied"},
		},
	}
	for testNum, test := range tests {
		t.Run(fmt.Sprintf("%d %s", testNum+1, test.name), func(t *testing.T) {
			execKMSTest(t, test, adminTestBed)
		})
	}
}

func TestKMSHandlersKeyStatus(t *testing.T) {

	architecture, ctxt := setArch(goarch)
	architecture.Init(ctxt)
	lexer := lex.NewLexer(input)
	parser := NewParser(ctxt, architecture, lexer)
	pList := new(obj.Plist)
	var ok bool
	testOut = new(strings.Builder) // The assembler writes test output to this buffer.
	ctxt.Bso = bufio.NewWriter(os.Stdout)
	ctxt.IsAsm = true
	defer ctxt.Bso.Flush()
	failed := false

				return
			}
			p.labels[label] = prog
		}
		p.pendingLabels = p.pendingLabels[0:0]
	}
	prog.Pc = p.pc
	if *flags.Debug {
		fmt.Println(p.lineNum, prog)
	}
	if testOut != nil {
		fmt.Fprintln(testOut, prog)
	}
}

// validSymbol checks that addr represents a valid name for a pseudo-op.
func (p *Parser) validSymbol(pseudo string, addr *obj.Addr, offsetOk bool) bool {

        assertThat(map.get("test3"), is(nullValue()));
        assertThat(map.getAt(0), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testPut() throws Exception {
        assertThat(map.put("1", "test3"), is("test"));
        assertThat(map.get("1"), is("test3"));
        assertThat(map.getAt(1), is("test3"));
        map.put(null, "test4");

    @Mock
    private SmbResourceLocator mockSmbResourceLocator;
    @Mock
    private SmbPipeHandle mockSmbPipeHandle;
    @Mock
    private BufferCache mockBufferCache;

    private static final String TEST_URL = "ncacn_np:server[\\pipe\\test]";
    private static final String TEST_SERVER = "server";
    private static final String TEST_ENDPOINT = "\\pipe\\test";

    @BeforeEach
    void setUp() throws IOException {

  /* The names of the expected method that tests null checks. */
  private static final ImmutableList<String> NULL_TEST_METHOD_NAMES =
      ImmutableList.of(
          "testNulls", "testNull",
          "testNullPointers", "testNullPointer",
          "testNullPointerExceptions", "testNullPointerException");

  /* The names of the expected method that tests serializable. */