import org.lastaflute.web.validation.Required;

/**
 * @author shinsuke
 * @author Keiichi Watanabe
 */
public class UploadForm {

    @Required
    public String dictId;

    @Required
    public MultipartFormFile kuromojiFile;

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.utflute.lastaflute.WebContainerTestCase;

public abstract class UnitFessTestCase extends WebContainerTestCase {
    @Override
    protected String prepareConfigFile() {
        return "test_app.xml";
    }

    @Override
    public void tearDown() throws Exception {
        ComponentUtil.setFessConfig(null);
        super.tearDown();
    }

@GwtCompatible
@ElementTypesAreNonnullByDefault
public class TreeBasedTableColumnTest extends ColumnTests {
  public TreeBasedTableColumnTest() {
    super(false, true, true, true, false);
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return TreeBasedTable.create();
  }

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;

/** Simple derived class to verify that we handle generics correctly. */
@GwtCompatible
class Derived extends Base {
  public Derived(String s) {
    super(s);
  }

  private static final long serialVersionUID = 0;

@GwtCompatible
@ElementTypesAreNonnullByDefault
public class HashBasedTableColumnTest extends ColumnTests {
  public HashBasedTableColumnTest() {
    super(false, true, true, true, false);
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return HashBasedTable.create();
  }

@GwtCompatible
@ElementTypesAreNonnullByDefault
public class TreeBasedTableColumnMapTest extends ColumnMapTests {
  public TreeBasedTableColumnMapTest() {
    super(false, true, true, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    return TreeBasedTable.create();
  }

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestLocking(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Locking{Strength: clause.LockingStrengthUpdate}},
			"SELECT * FROM `users` FOR UPDATE", nil,
		},
		{

/**
 * @author shinsuke
 *
 */
public interface Transformer {

    ResultData transform(ResponseData responseData);

    Object getData(AccessResultData<?> accessResultData);

    String getName();

type OrderByColumn struct {
	Column  Column
	Desc    bool
	Reorder bool
}

type OrderBy struct {
	Columns    []OrderByColumn
	Expression Expression
}

// Name where clause name
func (orderBy OrderBy) Name() string {
	return "ORDER BY"
}

// Build build where clause
func (orderBy OrderBy) Build(builder Builder) {
	if orderBy.Expression != nil {
		orderBy.Expression.Build(builder)
	} else {

/**
 * @author shinsuke
 * @author Keiichi Watanabe
 */
public class EditForm extends CreateForm {

    @Required
    @ValidateTypeFailure
    public Long id;

    public String getDisplayId() {
        return dictId + ":" + id;
    }