import (
	"context"
	"errors"
	"sync"
	"testing"
	"time"

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func TestPreparedStmt(t *testing.T) {
	tx := DB.Session(&gorm.Session{PrepareStmt: true})

	if _, ok := tx.ConnPool.(*gorm.PreparedStmtDB); !ok {
		t.Fatalf("should assign PreparedStatement Manager back to database when using PrepareStmt mode")
	}

						if _, isZero := pkField.ValueOf(db.Statement.Context, rv); isZero {
							db.AddError(pkField.Set(db.Statement.Context, rv, insertID))
							insertID += pkField.AutoIncrementIncrement
						}
					}
				}
			case reflect.Struct:
				_, isZero := pkField.ValueOf(db.Statement.Context, db.Statement.ReflectValue)
				if isZero {
					db.AddError(pkField.Set(db.Statement.Context, db.Statement.ReflectValue, insertID))
				}
			}

        StringBuilder methodKey = new StringBuilder(method.getName());

        for (Class<?> parameterType : parameterTypes) {
            // If the argument type is primitive then we want
            // to convert our primitive type signature to the
            // corresponding Object type so introspection for
            // methods with primitive types will work correctly.
            if (parameterType.isPrimitive()) {

	n, perr := strconv.ParseInt(nStr, 10, 0) // Intentionally parse as native int
	if perr != nil || n < 5 || n > int64(len(s)) {
		return "", "", s, ErrHeader
	}
	n -= int64(len(nStr) + 1) // convert from index in s to index in rest
	if n <= 0 {
		return "", "", s, ErrHeader
	}

	// Extract everything between the space and the final newline.
	rec, nl, rem := rest[:n-1], rest[n-1:n], rest[n:]

            }
            return this.handle;
        }
        return this.handle.acquire();
    }

    /**
     * Converts an SmbException to an IOException
     *
     * @param se the SmbException to convert
     * @return an IOException wrapping the SmbException
     */
    protected static IOException seToIoe(final SmbException se) {
        IOException ioe = se;

            assertEquals(200, enumInstance.level);
            assertNotNull(enumInstance.info);
        }
    }

    @Test
    @DisplayName("getEntries should properly convert DFS roots with special characters")
    void testGetEntries_specialCharacters() throws Exception {
        // Create array with special character names
        netdfs.DfsEnumArray200 specialArray = new netdfs.DfsEnumArray200();

        Resource resourceWithTarget = new Resource();
        resourceWithTarget.setDirectory("src/main/custom");
        resourceWithTarget.setTargetPath("custom-output");

        // Convert through DefaultSourceRoot to ensure targetPath is preserved
        DefaultSourceRoot sourceRootFromResource =
                new DefaultSourceRoot(project.getBaseDirectory(), ProjectScope.MAIN, resourceWithTarget.getDelegate());

// Get upload latency of each object size range
func (rl ReplicationLatency) getUploadLatency() (ret map[string]uint64) {
	ret = make(map[string]uint64)
	avg := rl.UploadHistogram.GetAvgData()
	for k, v := range avg {
		// Convert nanoseconds to milliseconds
		ret[sizeTagToString(k)] = uint64(v.avg() / time.Millisecond)
	}
	return ret
}

// Update replication upload latency with a new value

// SetModTime sets the [Modified], [ModifiedTime], and [ModifiedDate] fields
// to the given time in UTC.
//
// Deprecated: Use [Modified] instead.
func (h *FileHeader) SetModTime(t time.Time) {
	t = t.UTC() // Convert to UTC for compatibility
	h.Modified = t
	h.ModifiedDate, h.ModifiedTime = timeToMsDosTime(t)
}

const (
	// Unix constants. The specification doesn't mention them,

```JSON
{
  "detail": "Item not found"
}
```

/// tip

When raising an `HTTPException`, you can pass any value that can be converted to JSON as the parameter `detail`, not only `str`.

You could pass a `dict`, a `list`, etc.

They are handled automatically by **FastAPI** and converted to JSON.

///

## Add custom headers { #add-custom-headers }