class CheckTest {

    private Check checkGoal;
    private StrategyOrchestrator mockOrchestrator;

    @BeforeEach
    void setUp() {
        mockOrchestrator = mock(StrategyOrchestrator.class);
        checkGoal = new Check(mockOrchestrator);
    }

    private UpgradeContext createMockContext() {
        return TestUtils.createMockContext();
    }

    @Nested
    @DisplayName("Modification Behavior")

	err := r.readCloser.Close()
	for range r.valueCh {
		// Drain values so we don't leak a goroutine.
		// Since we have closed the input, it should fail rather quickly.
	}
	return err
}

// NewReader - creates new JSON reader using readCloser.
func NewReader(readCloser io.ReadCloser, args *ReaderArgs) *Reader {
	readCloser = &syncReadCloser{rc: readCloser}

    @Resource
    protected DictionaryManager dictionaryManager;

    /** The Fess configuration for accessing system settings. */
    @Resource
    protected FessConfig fessConfig;

    /**
     * Constructs a new stopwords service.
     */
    public StopwordsService() {
        // do nothing
    }

    /**
     * Retrieves a list of stopwords for a given dictionary and pager.
     *

    @Resource
    protected DictionaryManager dictionaryManager;

    /** The Fess configuration for accessing system settings. */
    @Resource
    protected FessConfig fessConfig;

    /**
     * Constructs a new synonym service.
     */
    public SynonymService() {
        // do nothing
    }

    /**
     * Retrieves a list of synonyms for a given dictionary and pager.
     *

<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".

For more information on release notes see: https://git.k8s.io/community/contributors/guide/release-notes.md
-->
```release-note

```

     */
    public Trans2SetFileInformation(final Configuration config, final int fid, final int attributes, final long createTime,
            final long lastWriteTime, final long lastAccessTime) {
        this(config, fid, new FileBasicInfo(createTime, lastAccessTime, lastWriteTime, 0L, attributes | 0x80));
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = this.getSubCommand();

		return 0, auth.ErrInvalidDuration
	}

	dur := time.Duration(d) * time.Second

	if dur < minExpiry || dur > maxExpiry {
		return 0, auth.ErrInvalidDuration
	}
	return dur, nil
}

// Lookup returns a new Config by merging the given K/V config
// system with environment variables.
func Lookup(kvs config.KVS) (Config, error) {
	if err := config.CheckValidKeys(config.IdentityTLSSubSys, kvs, DefaultKVS); err != nil {

</p>

<p>
For example, <code>new(int)</code> and <code>new(123)</code> each
return a pointer to a new variable of type <code>int</code>.
The value of the first variable is <code>0</code>, and the value
of the second is <code>123</code>. Similarly
</p>

<pre>
type S struct { a int; b float64 }
new(S)
</pre>

<p>

### Declare the dependency, in the "dependant" { #declare-the-dependency-in-the-dependant }

The same way you use `Body`, `Query`, etc. with your *path operation function* parameters, use `Depends` with a new parameter:

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[13,18] *}

Although you use `Depends` in the parameters of your function the same way you use `Body`, `Query`, etc, `Depends` works a bit differently.

    }
    expected_stride *= shape_arr[i];
  }
  return valid;
}
}  // namespace

void* TFE_GetDLDevice(TFE_TensorHandle* h, TF_Status* status) {
  auto dl_device = GetDlContext(h, status);
  return new DLDevice{dl_device.device_type, dl_device.device_id};
}

void TFE_CallDLManagedTensorDeleter(void* dlm_ptr) {
  DLManagedTensor* dlMTensor = static_cast<DLManagedTensor*>(dlm_ptr);
  if (dlMTensor->deleter != nullptr) {