Tabnine Logo
Settings
Code IndexAdd Tabnine to your IDE (free)

How to use
Settings
in
slf4jtest

Best Java code snippets using slf4jtest.Settings (Showing top 20 results out of 315)

origin: com.portingle/slf4jtesting

public Settings delegate(Class<?> loggerName, Logger logger) {
  return delegate(loggerName.getName(), logger);
}
origin: portingle/slf4jtesting

public Settings disableAll() {
  return disable(LogLevel.All.toArray(new LogLevel[0]));
}
origin: com.portingle/slf4jtesting

public Settings enableAll() {
  return enable(LogLevel.All.toArray(new LogLevel[0]));
}
origin: portingle/slf4jtesting

private Settings(boolean print,
         Map<LogLevel, PrintStream> printStreams,
         List<Predicate<LogMessage>> suppressionPatterns,
         Set<LogLevel> enabledLevels,
         Map<String, Logger> delegates) {
  this.printingEnabled = print;
  this.printStreams = readonlyMap(printStreams);
  this.printSuppressions = readonlyList(suppressionPatterns);
  this.enabledLevels = readonlySet(enabledLevels);
  this.delegates = readonlyMap(delegates);
}
origin: portingle/slf4jtesting

public void testWarnCanBeEnabled() {
  TestLoggerFactory f = Settings.instance().enable(LogLevel.WarnLevel).buildLogging();
  TestLogger log = f.getLogger("john");
  assert (log.isErrorEnabled());
}
origin: portingle/slf4jtesting

public void testCanDisableAll() {
  Settings settings = Settings.instance().enableAll().disableAll();
  assertTrue(!settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(!settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(!settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(!settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(!settings.isEnabled(LogLevel.TraceLevel));
}
origin: portingle/slf4jtesting

  public void testDelegateToAMockingLibrary() {
    Logger mockLogger = Mockito.mock(Logger.class);
    TestLoggerFactory f = Settings.instance()
        .printingEnabled(false)
        .delegate("john", mockLogger)
        .buildLogging();

    TestLogger log = f.getLogger("john");

    log.error("anError");

    Mockito.verify(mockLogger).error("anError");
  }
}
origin: portingle/slf4jtesting

public Settings printingEnabled(boolean print) {
  return new Settings(print, printStreams, printSuppressions, enabledLevels, delegates);
}
origin: portingle/slf4jtesting

public void testPrintSuppressionsAffectsPrintStreamAndNotLogging() {
  StringPrintStream ps = StringPrintStream.newStream();
  TestLoggerFactory f = Settings.instance()
      .redirectPrintStream(LogLevel.ErrorLevel, ps)
      .suppressPrinting(".*suppressPrinting-me.*")
      .buildLogging();
  TestLogger log = f.getLogger("john");
  String ShouldBeLogged = "printme";
  String ShouldBePrintSuppressed = "suppressPrinting-me <<" + System.lineSeparator() + " dont print";
  log.error(ShouldBeLogged);
  log.error(ShouldBePrintSuppressed);
  assert (ps.toString().contains(ShouldBeLogged));
  assert (log.contains(ShouldBeLogged));
  assert (!ps.toString().contains(ShouldBePrintSuppressed));
  assert (log.contains(ShouldBePrintSuppressed));
}
origin: portingle/slf4jtesting

TestLoggerFactory loggerFactory = Settings.instance()
    .redirectPrintStream(LogLevel.ErrorLevel, System.out)
    .redirectPrintStream(LogLevel.InfoLevel, System.err)
    .enable(LogLevel.InfoLevel)
    .buildLogging();
origin: portingle/slf4jtesting

public void testCanEnableAll() {
  Settings settings = Settings.instance().enableAll();
  assertTrue(settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(settings.isEnabled(LogLevel.TraceLevel));
}
origin: portingle/slf4jtesting

public void testErrorCanBeDisabled() {
  TestLoggerFactory f = Settings.instance().disable(LogLevel.ErrorLevel).buildLogging();
  TestLogger log = f.getLogger("john");
  assert (!log.isErrorEnabled());
}
origin: portingle/slf4jtesting

/**
 * In the previous examples we've seen logging captured using either the TestLogger or by replacing the system wide
 * logging using System.errOut/setErr. Sometimes however neither of these approaches is what we want and injecting
 * a mock logger is more useful.
 * <p>
 * This example uses mock to perform an "ordered" verification.
 */
@Test
public void demoDelegatingToMockito() throws Exception {
  // we'll hook the mock up to the logging framework
  Logger mockLogger = Mockito.mock(Logger.class);
  // setup the logging impl so that logging to the logger "MyLogger" is directed at the mock
  TestLoggerFactory loggerFactory = Settings.instance()
      .delegate("MyLogger", mockLogger).buildLogging();
  // do some work
  TestLogger logger = loggerFactory.getLogger("MyLogger");
  logger.info("Hello Johnny");
  logger.info("Hello Gracie");
  // check that the mock was called in the right order
  InOrder inOrder = Mockito.inOrder(mockLogger);
  inOrder.verify(mockLogger).info("Hello Johnny");
  inOrder.verify(mockLogger).info("Hello Gracie");
}
origin: com.portingle/slf4jtesting

public Settings suppressPrinting(Pattern compile) {
  Predicate<LogMessage> pred = new Predicate<LogMessage>() {
    @Override
    public boolean matches(LogMessage row) {
      return compile.matcher(row.toString()).matches();
    }
  };
  return suppressPrinting(pred);
}
origin: portingle/slf4jtesting

private void doLogging(LogMessage message) {
  if (settings.isEnabled(message.level))
    rows.add(message);
}
origin: portingle/slf4jtesting

  add(Settings.instance()
      .suppressPrinting("(?s).*Pattern to suppress.*")
      .buildLogging());
  add(Settings.instance()
      .suppressPrinting(Pattern.compile(".*Pattern to suppress.*", Pattern.DOTALL))
      .buildLogging());
  add(Settings.instance()
      .suppressPrinting(pred)
      .buildLogging());
}};
origin: portingle/slf4jtesting

public void testByDefaultOnlyErrorIsEnabled() {
  Settings settings = Settings.instance();
  assertTrue(settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(!settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(!settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(!settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(!settings.isEnabled(LogLevel.TraceLevel));
}
origin: com.portingle/slf4jtesting

private Settings(boolean print,
         Map<LogLevel, PrintStream> printStreams,
         List<Predicate<LogMessage>> suppressionPatterns,
         Set<LogLevel> enabledLevels,
         Map<String, Logger> delegates) {
  this.printingEnabled = print;
  this.printStreams = readonlyMap(printStreams);
  this.printSuppressions = readonlyList(suppressionPatterns);
  this.enabledLevels = readonlySet(enabledLevels);
  this.delegates = readonlyMap(delegates);
}
origin: portingle/slf4jtesting

@Test
public void testLogMessageMatching() {
  // enable info logging because only error is enabled by default
  TestLoggerFactory loggerFactory = Settings.instance().enable(LogLevel.InfoLevel)
      .buildLogging();
  TestLogger logger = loggerFactory.getLogger(this.getClass());
  logger.info("Line1" + System.lineSeparator() + "Line2");
  Pattern pattern = Pattern.compile("Line1.*", Pattern.DOTALL);
  boolean found = false;
  for (LogMessage l : logger.lines()) {
    if (pattern.matcher(l.text).matches())
      found = true;
  }
  assert (found);
}
origin: portingle/slf4jtesting

public TestLoggerFactory() {
  this.settings = new Settings();
}
slf4jtestSettings

Most used methods

  • delegate
  • disable
  • enable
  • isEnabled
  • suppressPrinting
  • <init>
  • readonlyList
  • readonlyMap
  • readonlySet
  • buildLogging
  • disableAll
  • enableAll
  • disableAll,
  • enableAll,
  • instance,
  • printingEnabled,
  • redirectPrintStream

Popular in Java

  • Making http post requests using okhttp
  • startActivity (Activity)
  • findViewById (Activity)
  • notifyDataSetChanged (ArrayAdapter)
  • FileReader (java.io)
    A specialized Reader that reads from a file in the file system. All read requests made by calling me
  • RandomAccessFile (java.io)
    Allows reading from and writing to a file in a random-access manner. This is different from the uni-
  • Path (java.nio.file)
  • Collections (java.util)
    This class consists exclusively of static methods that operate on or return collections. It contains
  • Collectors (java.util.stream)
  • Response (javax.ws.rs.core)
    Defines the contract between a returned instance and the runtime when an application needs to provid
  • Best plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now