└── tests
        ├── __init__.py
        └── test_sql_app.py
```

## Create the new database session

First, we create a new database session with the new database.

We'll use an in-memory database that persists during the tests instead of the local file `sql_app.db`.

But the rest of the session code is more or less the same, we just copy it.

```Python hl_lines="8-13"

		// See https://github.com/kubernetes/kubernetes/issues/32551.
		//
		// CLOSE_WAIT conntrack state occurs when the Linux kernel
		// sees a FIN from the remote server. Note: this is a half-close
		// condition that persists as long as the local side keeps the
		// socket open. The condition is rare as it is typical in most
		// protocols for both sides to issue a close; this typically
		// occurs when the local socket is lazily garbage collected.

different containers instances that are run from this image.  The first is a "data" container to store all data that needs to persist across to support incremental builds. Next there is an "rsync" container that is used to transfer data in and out to the data container.  Lastly there is a "build" container that is used for actually doing build actions.  The data container persists across runs while the rsync and build containers are deleted after each use.

`rsync` is used transparently behind...

     * We use this to ensure we don't print the same warning multiple times to the user
     * if {@link #checkExpiration()} is called multiple times while an unhealthy
     * memory condition persists.
     */
    private DaemonExpirationStatus mostSevereStatus = DO_NOT_EXPIRE;
    private final Lock statusLock = new ReentrantLock();

    private final DaemonHealthStats stats;

        result.reason == "since the JVM garbage collector is thrashing and after running out of JVM Metaspace"
    }

    def "logs are not spammed if checkExpiration is called multiple times while an unhealthy condition persists"() {
        given:
        Logger logger = Mock(Logger)
        DaemonHealthStats stats = Mock(DaemonHealthStats)
        stats.getNonHeapStats() >> belowThreshold

	}
	for key, value := range secret.Data {
		credentials[key] = string(value)
	}

	return credentials, nil
}

// saveVolumeData persists parameter data as json file at the provided location
func saveVolumeData(dir string, fileName string, data map[string]string) error {
	dataFilePath := filepath.Join(dir, fileName)

// Check that an argument ("__tf_file_prefix") is created.
// CHECK-SAME: %[[ARG_0:.*]]: tensor<!tf_type.string> {tf_saved_model.index_path = ["__tf_file_prefix"]}

// Original `AssignVariableOp(VarHandleOp, Const)` pattern persists.
// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"() {{.*value = dense<1.000000e\+00> : tensor<2xf32>.*}}
// CHECK-DAG: %[[VAR_HANDLE:.*]] = "tf.VarHandleOp"() {{.*shared_name = "var_0".*}} : () -> tensor<!tf_type.resource<tensor<2xf32>>>

// Tensor with AsyncValueTensor; 3. Tensor with raw device mem pointer.
// For case 3, we need to create a PjRtBuffer from the raw device mem pointer,
// and we need to ensure the PjRtBuffer persists till XLA computation is
// complete. Therefore we put the newly created PjRtBuffer into `owned_args`.
// Caller is responsible to ensure `owned_args` lives till the end of XLA
// computation.

      DeviceCompilerClient<ExecutableType, ClientType>* client) const;

  // Tries to serialize an already built `executable` and persist it on disk. If
  // unable to do so, tries to build a serialized executable using the AOT
  // pipeline and persists that to disk.
  // TODO(b/255826209): Take in Signature instead hash and string once cache
  // is refactored.
  virtual Status TryToPersistExecutable(

You can verify the problem with Gradle scripts by running `gradle help`, which executes configuration scripts but no Gradle tasks.
If the error persists, it means the build configuration is problematic.
If not, the problem exists when executing one or more requested tasks (Gradle executes configuration scripts first, followed by build steps).