void testBuilderCommon() {
        List<String> msgs = new ArrayList<>();
        msgs.add("*****************************************************************");
        msgs.add("* Your build is requesting parallel execution, but project      *");
        msgs.add("* contains the following plugin(s) that have goals not marked   *");
        msgs.add("* as @threadSafe to support parallel building.                  *");

		t.Errorf("Should found two users's name in 1, 2, but got %v", len(users1))
	}

	DB.Scopes(NameIn1And2, NameIn2And3).Find(&users2)
	if len(users2) != 1 {
		t.Errorf("Should found one user's name is 2, but got %v", len(users2))
	}

	DB.Scopes(NameIn([]string{users[0].Name, users[2].Name})).Find(&users3)
	if len(users3) != 2 {
		t.Errorf("Should found two users's name in 1, 3, but got %v", len(users3))
	}

This will make `tags` be a list, although it doesn't declare the type of the elements of the list.

## List fields with type parameter { #list-fields-with-type-parameter }

But Python has a specific way to declare lists with internal types, or "type parameters":

### Declare a `list` with a type parameter { #declare-a-list-with-a-type-parameter }

	}

	if tableType.Schema() != tblSchema {
		t.Fatalf("expected tblSchema to be %s but got %s", tblSchema, tableType.Schema())
	}

	if tableType.Name() != tblName {
		t.Fatalf("expected table name to be %s but got %s", tblName, tableType.Name())
	}

	if tableType.Type() != tblType {
		t.Fatalf("expected table type to be %s but got %s", tblType, tableType.Type())
	}

	comment, ok := tableType.Comment()

		t.Run(testCase.s, func(t *testing.T) {
			endpoints, secure, err := parseEndpoints(testCase.s)
			if err != nil && testCase.success {
				t.Errorf("expected to succeed but failed with %s", err)
			}
			if !testCase.success && err == nil {
				t.Error("expected failure but succeeded instead")
			}
			if testCase.success {
				if !reflect.DeepEqual(endpoints, testCase.endpoints) {

		t.Errorf("should got failed to save, but error is nil")
	}

	if DB.First(&Product4{}, "name = ?", product.Name).Error == nil {
		t.Errorf("should got RecordNotFound, but got nil")
	}

	product = Product4{Name: "Product-2", Price: 100, Item: ProductItem{Code: "valid"}}
	if err := DB.Create(&product).Error; err != nil {
		t.Errorf("should create product, but got error %v", err)
	}

                                    "Expected text value 'http://www.apache.org/path/to/parent/child-artifact-id/' but was "
                                            + "'http://www.apache.org/path/to/parent/../child-artifact-id/'"),
                    afe.getMessage());
        }
        // but ok from repo: local disk is ignored
        testInheritance("tricky-flat-artifactId-urls", true);

{* ../../docs_src/python_types/tutorial001_py39.py hl[2] *}

### Edit it { #edit-it }

It's a very simple program.

But now imagine that you were writing it from scratch.

At some point you would have started the definition of the function, you had the parameters ready...

But then you have to call "that method that converts the first letter to upper case".

Was it `upper`? Was it `uppercase`? `first_uppercase`? `capitalize`?

	for i, test := range kmsParseHTTPTests {
		_, _, err := S3KMS.ParseHTTP(test.Header)
		if err == nil && test.ShouldFail {
			t.Errorf("Test %d: should fail but succeeded", i)
		}
		if err != nil && !test.ShouldFail {
			t.Errorf("Test %d: should pass but failed with: %v", i, err)
		}
	}
}

var s3IsRequestedTests = []struct {
	Header   http.Header
	Expected bool
}{

All the same `parameters`, `responses`, `dependencies`, `tags`, etc.

/// tip

In this example, the variable is called `router`, but you can name it however you want.

///

We are going to include this `APIRouter` in the main `FastAPI` app, but first, let's check the dependencies and another `APIRouter`.

## Dependencies { #dependencies }