) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage, init = {
        val os = Os.LINUX
        val buildTypeThis = this
        val testProject = "smallJavaMultiProject"

        fun BuildSteps.gradleStep(tasks: List<String>) {
            gradleWrapper {
                name = "GRADLE_RUNNER"
                gradleParams =
                    (
                        tasks +

import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
import com.google.common.collect.testing.OneSizeTestContainerGenerator;
import com.google.common.collect.testing.SampleElements;
import com.google.common.collect.testing.SetTestSuiteBuilder;
import com.google.common.collect.testing.features.Feature;
import com.google.common.testing.SerializableTester;
import java.util.ArrayList;
import java.util.Collection;

        @DisplayName("Should create mock with string name")
        void testMockWithStringName() {
            String nameStr = "MOCK_CONTEXT";
            MockCreateContextResponse mock = new MockCreateContextResponse(nameStr);

            assertArrayEquals(nameStr.getBytes(StandardCharsets.UTF_8), mock.getName());
        }

        @Test
        @DisplayName("Should handle null string name")

```JSON
{"item_id":3}
```

/// check | Verifique
Perceba que o valor que sua função recebeu (e retornou) é `3`, como um `int` do Python, não uma string `"3"`.

Então, com essa declaração de tipo, o **FastAPI** fornece <abbr title="convertendo a string que vem de um request HTTP em dados Python">"parsing"</abbr> automático do request.
///

## Validação de dados { #data-validation }

    redQueue.execute("task one", 100.µs) {
      // Do nothing.
    }

    redQueue.execute("task two", 200.µs) {
      // Do nothing.
    }

    assertThat(redQueue.scheduledTasks.toString()).isEqualTo("[task one, task two]")

    assertThat(testLogHandler.takeAll()).containsExactly(
      "FINE: Q10000 scheduled after 100 µs: task one",
      "FINE: Q10000 scheduled after 200 µs: task two",
    )

  private static SuccessorsFunction<Character> createDirectedGraph(String... edges) {
    return createGraph(/* directed= */ true, edges);
  }

  private static SuccessorsFunction<Character> createUndirectedGraph(String... edges) {
    return createGraph(/* directed= */ false, edges);
  }

  /**
   * Creates a graph from a list of node pairs (encoded as strings, e.g. "ab" means that this graph

     */
    public DataStoreException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a new DataStoreException with the specified message.
     *
     * @param message the error message
     */
    public DataStoreException(final String message) {
        super(message);
    }

    /**

                Arguments.of(0x00000002, SmbException.getMessageByCode(0x00000002)),
                // Unknown code → hex string (uppercase)
                Arguments.of(0xDEADBEEF, "0xDEADBEEF"));
    }

    @ParameterizedTest
    @MethodSource("errorCodes")
    void constructorInitialisesMessageAndStatus(int code, String expectedMsg) {
        SmbAuthException e = new SmbAuthException(code);

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"testing"
)

func TestExtractPrefixAndSuffix(t *testing.T) {
	specs := []struct {
		path, prefix, suffix string
		expected             string
	}{
		{"config/iam/groups/foo.json", "config/iam/groups/", ".json", "foo"},
		{"config/iam/groups/./foo.json", "config/iam/groups/", ".json", "foo"},

		DB.Preload("Toy").Find(&pet4, "id = ?", pet.ID)
		CheckPet(t, pet4, pet)
	})

	t.Run("Restriction", func(t *testing.T) {
		type CustomizeAccount struct {
			gorm.Model
			UserID  sql.NullInt64
			Number  string `gorm:"<-:create"`
			Number2 string
		}

		type CustomizeUser struct {
			gorm.Model
			Name    string
			Account CustomizeAccount `gorm:"foreignkey:UserID"`
		}

		DB.Migrator().DropTable(&CustomizeUser{})