String expected = canEncode ? String.valueOf(icon.getUnicodeChar()) : icon.getAsciiFallback();
            assertEquals(expected, result, "Icon should match charset encoding capability for " + icon);
        }
    }

    @Test
    @DisplayName("should be consistent across multiple calls")
    void shouldBeConsistentAcrossMultipleCalls() {

		{rulesMapCase4, ObjectCreatedPut, "2000/photo.png", NewTargetIDSet(TargetID{"2", "amqp"})},
	}

	for i, testCase := range testCases {
		result := testCase.rulesMap.Match(testCase.eventName, testCase.objectName)

		if !reflect.DeepEqual(result, testCase.expectedResult) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
		}
	}
}

    <module name="SuppressWarningsHolder" />

    <module name="AvoidStarImport" />

    <!-- Unused imports are forbidden -->
    <module name="UnusedImports" />

    <!-- Non-inner classes must be in files that match their names. -->
    <module name="OuterTypeFilename" />

    <!-- No line wraps inside of import and package statements. -->
    <module name="NoLineWrap" />

    <!-- only one statement per line should be allowed -->

                if (num.intValue() > fessConfig.getPagingSearchPageMaxSizeAsInteger().intValue() || num.intValue() <= 0) {
                    num = fessConfig.getPagingSearchPageMaxSizeAsInteger();
                }
            } catch (final NumberFormatException e) {
                num = fessConfig.getPagingSearchPageSizeAsInteger();
            }
        }
        return num;
    }

    @Override
    public String getQuery() {

        }, XContentType.JSON)) {
            message = ((ByteArrayOutputStream) out).toString(Constants.UTF_8);
            if (StringUtil.isBlank(message)) {
                message = "{}";
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Gets the status.
     *
     * @return the status
     */
    public int getStatus() {

                        outputCallback.accept(line);
                    }
                    if (list.size() > bufferSize) {
                        list.remove(0);
                    }
                }
            } catch (final Exception e) {
                running = false;
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to process an input stream.", e);
                }
            }
        }

            final WebConfigService webConfigService = ComponentUtil.getComponent(WebConfigService.class);
            try {
                webConfig = webConfigService.getWebConfig(getWebConfigId()).get();
            } catch (final Exception e) {
                logger.warn("Web Config {} does not exist.", getWebConfigId(), e);
            }
        }
        return webConfig;
    }

    public String getId() {

      return false // The signer can't have this many intermediates beneath it.
    }
    return try {
      toVerify.verify(signingCert.publicKey)
      true
    } catch (verifyFailed: GeneralSecurityException) {
      false
    }
  }

  override fun hashCode(): Int = trustRootIndex.hashCode()

  override fun equals(other: Any?): Boolean =
    if (other === this) {

  public void testSet_unsupportedByEmptyList() {
    try {
      getList().set(0, e3());
      fail("set() should throw UnsupportedOperationException or IndexOutOfBoundsException");
    } catch (UnsupportedOperationException | IndexOutOfBoundsException expected) {
    }
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)
  @ListFeature.Require(SUPPORTS_SET)

            // Add some padding
            for (int i = 0; i < 300; i++) {
                dos.writeByte(0);
            }

            return baos.toByteArray();
        } catch (IOException e) {
            throw new PACDecodingException("Failed to create test data", e);
        }
    }