* processing or telecommunication systems, more especially switching devices "on" or "off." (If a
   * single "stop" control is required to interrupt or turn off ancillary devices, DC4 is the
   * preferred assignment.)
   *
   * @since 8.0
   */
  public static final byte DC1 = 17; // aka XON

  /**
   * Transmission On: Although originally defined as DC1, this ASCII control character is now better

        assertFalse("Thread should not be started yet", thread.isAlive());
    }

    @Test
    public void test_processAssignment() throws IOException {
        Process mockProcess = createMockProcess("assignment test");
        JobProcess jobProcess = new JobProcess(mockProcess);

        Process assignedProcess = jobProcess.getProcess();

      throwable = t;
    }

    if (throwable == null) {
      /*
       * The cast is safe: There was no exception, so the assignment from getDone must have
       * succeeded.
       */
      set(uncheckedCastNullableTToT(sourceResult));
      return;
    }

    if (!isInstanceOfThrowableClass(throwable, localExceptionType)) {

	var (
		assigns  []clause.Assignment
		assocOps []clause.Association
	)

	for _, item := range items {
		// Check if it's an AssociationAssigner
		if assocAssigner, ok := item.(clause.AssociationAssigner); ok {
			assocOps = append(assocOps, assocAssigner.AssociationAssignments()...)
		} else {
			assigns = append(assigns, item.Assignments()...)
		}
	}

	return setCreateOrUpdateG[T]{

     * This is an unsynchronized read! After the read, the function returns immediately or acquires
     * the lock to check again. Since an IDLE state was observed inside the preceding synchronized
     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to

If it was in a type annotation we could have used the vertical bar, as:

```Python
some_variable: PlaneItem | CarItem
```

But if we put that in the assignment `response_model=PlaneItem | CarItem` we would get an error, because Python would try to perform an **invalid operation** between `PlaneItem` and `CarItem` instead of interpreting that as a type annotation.

IncDec statement    Assignment
x++                 x += 1
x--                 x -= 1
</pre>


<h3 id="Assignment_statements">Assignment statements</h3>

<p>
An <i>assignment</i> replaces the current value stored in a <a href="#Variables">variable</a>
with a new value specified by an <a href="#Expressions">expression</a>.
An assignment statement may assign a single value to a single variable, or multiple values to a

   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
   * table is internally partitioned to try to permit the indicated number of concurrent updates
   * without contention. Because assignment of entries to these partitions is not necessarily
   * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to

    // of the values gets evicted. With weak keys, we use identity equality, which means using
    // System.identityHashCode, which means the assignment of keys to segments is nondeterministic,
    // so more than (maximumSize / #segments) keys could get assigned to the same segment, which
    // would cause one to be evicted.
    return new CacheBuilderFactory()

   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
   * table is internally partitioned to try to permit the indicated number of concurrent updates
   * without contention. Because assignment of entries to these partitions is not necessarily
   * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to