log4j.rootLogger=INFO,STDOUT
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.ImmediateFlush=true
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout

log4j.rootLogger=WARN,STDOUT
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.ImmediateFlush=true
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.ConversionPattern=%-5p %d [%t] %m%n

    assertSame(sb1FromIterable, joiner.appendTo(sb1FromIterable, set));
    assertEquals(0, sb1FromIterable.length());

    StringBuilder sb1FromIterator = new StringBuilder();
    assertSame(sb1FromIterator, joiner.appendTo(sb1FromIterator, set));
    assertEquals(0, sb1FromIterator.length());

    StringBuilder sb2 = new StringBuilder();
    assertSame(sb2, joiner.appendTo(sb2, array));
    assertEquals(0, sb2.length());

	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("appendInt failed: %v", r)
		}
	}()
	m[key] = append(m[key], 2018)
	return nil
}

func appendStr(m map[interface{}][]string, key interface{}) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("addStr failed: %v", r)
		}
	}()
	m[key] = append(m[key], "hello, go")
	return nil
}

		}
		out = AppendErr(out, fmt.Errorf("%s%s", ee, times))
		// reset seen log count
		logCountMap[item] = 0
	}
	return out
}

// NewErrs returns a slice of error with a single element err.
// If err is nil, returns nil.
func NewErrs(err error) Errors {
	if err == nil {
		return nil
	}
	return []error{err}
}

    }

    @Override
    public String toString() {
        return primitiveType.toString(array);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        primitiveType.appendTo(hasher, array);
    }

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {
        PrimitiveType valueType = PrimitiveType.maybeOfValue(value);

		} else {
			w.data = append(w.data, buf[:free]...)
			w.off = copy(w.data, buf[free:])
		}
	}
}

// appendTo appends stored bytes between from and to indices to the buf.
// Index from must be less or equal to index to and to must be less or equal to w.len().
func (w *window) appendTo(buf []byte, from, to uint32) []byte {
	dataLen := uint32(len(w.data))
	from += uint32(w.off)
	to += uint32(w.off)

	wrap := false

			state.appendKey(key)
			state.appendTime(val)
		} else {
			state.appendAttr(Time(key, val))
		}
	}
	// level
	key := LevelKey
	val := r.Level
	if rep == nil {
		state.appendKey(key)
		state.appendString(val.String())
	} else {
		state.appendAttr(Any(key, val))
	}
	// source
	if h.opts.AddSource {
		state.appendAttr(Any(SourceKey, r.source()))
	}
	key = MessageKey
	msg := r.Message

				t.Errorf("Marshal = %q; want %q", back, orig)
			}

			testAppendToMarshal(t, ipp)
		})
	}
}

type appendMarshaler interface {
	encoding.TextMarshaler
	AppendTo([]byte) []byte
}

// testAppendToMarshal tests that x's AppendTo and MarshalText methods yield the same results.
// x's MarshalText method must not return an error.
func testAppendToMarshal(t *testing.T, x appendMarshaler) {
	t.Helper()

                sb.append(" doesn't define any library.");
            } else {
                sb.append(" contains more than one library. Please select one of ");
                Joiner.on(", ").appendTo(sb, candidateLibraries);
            }
        } else {
            VariantComponent notMatchingRequirements = getNonMatchingLibrary();
            if (notMatchingRequirements != null) {