import peewee

from .database import db


class User(peewee.Model):
    email = peewee.CharField(unique=True, index=True)
    hashed_password = peewee.CharField()
    is_active = peewee.BooleanField(default=True)

    class Meta:
        database = db


class Item(peewee.Model):
    title = peewee.CharField(index=True)
    description = peewee.CharField(index=True)
    owner = peewee.ForeignKeyField(User, backref="items")

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc bar = beanDesc.getMethodDesc("bar", String.class);
        assertThat(bar, is(notNullValue()));
        assertThat(bar.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(bar.getMethod(), is(MyBean.class.getDeclaredMethod("bar", String.class)));
        assertThat(bar.getParameterTypes().length, is(1));

		<postConstruct name="addRule">
			<arg>defaultRule</arg>
		</postConstruct>
	</component>

	<component name="sitemapsRule" class="org.codelibs.fess.crawler.rule.impl.RegexRule" >
		<property name="ruleId">"sitemapsRule"</property>
		<property name="responseProcessor">
			<component class="org.codelibs.fess.crawler.processor.impl.SitemapsResponseProcessor">
			</component>
		</property>
		<postConstruct name="addRule">

/**
 * StringSearchModelInterpolator
 */
@Deprecated
@Named
@Singleton
public class StringSearchModelInterpolator extends AbstractStringBasedModelInterpolator {

    private static final Map<Class<?>, Field[]> FIELDS_BY_CLASS = new WeakHashMap<>();
    private static final Map<Class<?>, Boolean> PRIMITIVE_BY_CLASS = new WeakHashMap<>();

    public StringSearchModelInterpolator() {}

	<component name="dictionaryManager" class="org.codelibs.fess.dict.DictionaryManager">
	</component>

	<component name="kuromojiDictCreator"
		class="org.codelibs.fess.dict.kuromoji.KuromojiCreator">
	</component>
	<component name="synonymCreator"
		class="org.codelibs.fess.dict.synonym.SynonymCreator">
	</component>
	<component name="stemmerOverrideCreator"
		class="org.codelibs.fess.dict.stemmeroverride.StemmerOverrideCreator">

import okio.Path
import okio.buffer
import okio.source

abstract class RequestBody {
  /** Returns the Content-Type header for this body. */
  abstract fun contentType(): MediaType?

  /**
   * Returns the number of bytes that will be written to sink in a call to [writeTo],
   * or -1 if that count is unknown.
   */
  @Throws(IOException::class)
  open fun contentLength(): Long = commonContentLength()

import jcifs.DfsReferralData;
import jcifs.internal.smb1.trans2.Trans2GetDfsReferralResponse;


/**
 * @author mbechler
 *
 */
public class DfsReferralDataImpl implements DfsReferralDataInternal {

    private static final Logger log = LoggerFactory.getLogger(DfsReferralDataImpl.class);

    private int pathConsumed;
    private long ttl;
    private String server; // Server
    private String share; // Share

import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.helpers.DefaultHandler;

/**
 * @author shinsuke
 *
 */
public class SitemapsHelper {
    private static final Logger logger = LoggerFactory.getLogger(SitemapsHelper.class);

    protected int preloadSize = 512;

    public boolean isValid(final InputStream in) {
        return isValid(in, true);
    }

    assertThrows(IllegalArgumentException.class, () -> DoubleMath.mean(ImmutableList.<Double>of()));
    assertThrows(
        IllegalArgumentException.class, () -> DoubleMath.mean(ImmutableList.of(Double.NaN)));
    assertThrows(
        IllegalArgumentException.class,
        () -> DoubleMath.mean(ImmutableList.of(Double.POSITIVE_INFINITY)));
  }

    assertThrows(IllegalStateException.class, () -> setToTest.equals(wrappedSet));
    assertThrows(IllegalStateException.class, () -> setToTest.equals(copyOfWrappedSet));
    assertThrows(IllegalStateException.class, () -> setToTest.equals(copyOfModifiedSet));
    assertThrows(IllegalStateException.class, () -> wrappedSet.equals(setToTest));
    assertThrows(IllegalStateException.class, () -> copyOfWrappedSet.equals(setToTest));