assert middleware_state["context_b"] == "finished b with a: started a"
    assert middleware_state["context_a"] == "finished a"
    assert middleware_state["bg"] == "not set"
    assert state["context_b"] == "finished b with a: started a"
    assert state["context_a"] == "finished a"
    assert state["bg"] == "bg set - b: finished b with a: started a - a: finished a"


def test_sync_raise_raises():

    ) {
      lock.assertNotHeld()

      var remainingByteCount = byteCount

      while (remainingByteCount > 0L) {
        val finished: Boolean
        val flowControlError: Boolean
        ******@****.***ck {
          finished = this.finished
          flowControlError = remainingByteCount + readBuffer.size > maxByteCount
        }

      "FINE: Q10000 run again after  50 µs: task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 run again after 150 µs: task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
    )
  }

            }
        }

        /**
         * @param finished
         *            The finished to set.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * @return Returns the teminated.
         */
        public boolean isTeminated() {
            return teminated;
        }
    }

	// Filled during heal.
	HealedBuckets []string

	// ID of the current healing operation
	HealID string

	ItemsSkipped uint64
	BytesSkipped uint64

	RetryAttempts uint64

	Finished bool // finished healing, whether with errors or not

	// Add future tracking capabilities
	// Be sure that they are included in toHealingDisk
}

// loadHealingTracker will load the healing tracker from the supplied disk.

     * @throws CIFSException
     * 
     */
    SmbRandomAccess openRandomAccess ( String mode, int sharing ) throws CIFSException;


    /**
     * Opens the file for random access
     * 
     * @param mode
     *            access mode (r|rw)
     * @return random access file, needs to be closed when finished
     * @throws CIFSException
     */

		case "RetryAttempts":
			z.RetryAttempts, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RetryAttempts")
				return
			}
		case "Finished":
			z.Finished, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Finished")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ BYTE_TABLE[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

    @Override

        private final DataConfig dataConfig;

        private final IndexUpdateCallback indexUpdateCallback;

        private final DataStoreParams initParamMap;

        protected boolean finished = false;

        protected boolean running = false;

        private DataStore dataStore;

        protected DataCrawlingThread(final DataConfig dataConfig, final IndexUpdateCallback indexUpdateCallback,

   *
   * <p>This method waits 120 seconds before continuing with JVM termination, even if the executor
   * has not finished its work.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished
   * @return an unmodifiable version of the input which will not hang the JVM
   */
  @J2ktIncompatible