FastAPIが実際にチェックしているのは、それが「呼び出し可能」（関数、クラス、その他なんでも）であり、パラメータが定義されているかどうかということです。

**FastAPI** の依存関係として「呼び出し可能なもの」を渡すと、その「呼び出し可能なもの」のパラメータを解析し、サブ依存関係も含めて、*path operation関数*のパラメータと同じように処理します。

それは、パラメータが全くない呼び出し可能なものにも適用されます。パラメータのない*path operation関数*と同じように。

そこで、上で紹介した依存関係の`common_parameters`を`CommonQueryParams`クラスに変更します:

{* ../../docs_src/dependencies/tutorial002.py hl[11,12,13,14,15] *}

        // Verify independence of operations
        assertEquals(user1, chain.updateCalls.get(0));
        assertEquals(user2, chain.deleteCalls.get(0));
        assertEquals("user3", chain.changePasswordCalls.get(0).getKey());
        assertEquals(user1, chain.loadCalls.get(0));
    }

    // Test concurrent operations simulation
    public void test_implementation_sequentialOperations() {

import org.apache.maven.api.services.Result;

/**
 * A record representing the result of a single request operation, containing the original request,
 * the result (if successful), and any error that occurred during processing.
 * <p>
 * This class is immutable and thread-safe, suitable for use in concurrent operations.
 *
 * @param <REQ> The type of the request
 * @param <REP> The type of the response, which must extend {@code Result<REQ>}

        // of executing. Don't null out the latestTaskQueue field, because the work done here
        // may have scheduled more operations on another thread, and if those operations then
        // trigger reentrant calls that thread will have updated the latestTaskQueue field, and
        // we'd be interfering with their operation.
        executingTaskQueue.thread = null;
      }
    }

    private boolean trySetStarted() {

	if !ok {
		return 0, errors.New("unexpected Read operation")
	}

	n := copy(b, s)
	if len(s) > n {
		f.ops[0] = s[n:]
	} else {
		f.ops = f.ops[1:]
	}
	f.pos += int64(len(b))
	return n, nil
}

func (f *testFile) Write(b []byte) (int, error) {
	if len(b) == 0 {
		return 0, nil
	}
	if len(f.ops) == 0 {
		return 0, errors.New("unexpected Write operation")
	}
	s, ok := f.ops[0].(string)
	if !ok {

      return super.writeReplace();
    }
  }

  /**
   * Guaranteed to throw an exception and leave the list unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean addAll(int index, Collection<? extends E> newElements) {

 */
package jcifs.dcerpc.msrpc;

import jcifs.dcerpc.rpc.policy_handle;

/**
 * Microsoft RPC SAM close handle request.
 * This class implements the SAMR close handle operation.
 *
 * @author mbechler
 */
public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param handle the policy handle to close

     * Creates a new CreateForm instance.
     */
    public CreateForm() {
        // Default constructor
    }

    /** Dictionary identifier */
    @Required
    public String dictId;

    /** CRUD operation mode (CREATE, EDIT, etc.) */
    @ValidateTypeFailure
    public Integer crudMode;

    /** Token (word) to be added to the dictionary */
    @Required
    @Size(max = 1000)
    public String token;

		t.Errorf("MinIO %s: Failed to create HTTP request for testing the response when object Layer is set to `nil`.", instanceType)
	}
	// Executes the object layer set to `nil` test.
	// `ExecObjectLayerAPINilTest` manages the operation.
	ExecObjectLayerAPINilTest(t, nilBucket, "", instanceType, apiRouter, nilReq)
}

// Wrapper for calling HeadBucket HTTP handler tests for both Erasure multiple disks and single node setup.

func TestMultipartObjectCreation(t *testing.T) {
	ExecExtendedObjectLayerTest(t, testMultipartObjectCreation)
}

// Tests validate creation of part files during Multipart operation.
func testMultipartObjectCreation(obj ObjectLayer, instanceType string, t TestErrHandler) {
	var opts ObjectOptions
	err := obj.MakeBucket(context.Background(), "bucket", MakeBucketOptions{})
	if err != nil {