/**
     * 
     */
    private static final long serialVersionUID = 298752101881244000L;


    /**
     * 
     */
    public SmbEndOfFileException () {
        super("Unexpectedly reached end of file");
    }

		select {
		case <-s.ctx.Done():
			// ctx done, we should silently go away
			return
		default:
			// If the cniListener exits, at least we should record an error log
			log.Errorf("CNI listener server exiting unexpectedly: %v", err)
		}
	}()

	context.AfterFunc(s.ctx, func() {
		if err := s.cniListenServer.Close(); err != nil {
			log.Errorf("CNI listen server terminated with error: %v", err)
		} else {

    // Read the command.
    val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

    val command = fromSource.readByte() and 0xff

    val reserved = fromSource.readByte() and 0xff
    if (reserved != 0) throw ProtocolException("unexpected reserved: $reserved")

    val addressType = fromSource.readByte() and 0xff
    val toAddress =

      throws InterruptedException {
    while (!isThreadBlockedOnInstanceOf(t, blocker)) {
      if (t.getState() == Thread.State.TERMINATED) {
        throw new RuntimeException("Thread " + t + " exited unexpectedly");
      }
      Thread.sleep(1);
    }
  }

  private static boolean isThreadBlockedOnInstanceOf(Thread t, Class<?> blocker) {

	})
	t.Run("pod out of ambient", func(t *testing.T) {
		p, err := pluginServer.getPodWithRetry(log, podOutOfAmbient.Name, pod.Namespace)
		assert.Error(t, err)
		assert.Equal(t, true, strings.Contains(err.Error(), "unexpectedly not enrolled in ambient"))
		assert.Equal(t, p, nil)
	})
}

func TestCNIPluginServerPrefersCNIProvidedPodIP(t *testing.T) {
	fakePodIP := "11.1.1.12"
	_, addr, _ := net.ParseCIDR(fakePodIP + "/32")

			}
			checkOutput(t, w.String(), tt.expected, tt.unexpected)
		})
	}
}

func checkOutput(t *testing.T, output string, expected, unexpected []string) {
	t.Helper()
	for _, expected := range expected {
		if !strings.Contains(output, expected) {
			t.Errorf("expected %s included in writer output, did not find", expected)
		}
	}
	for _, unexpected := range unexpected {
		if strings.Contains(output, unexpected) {

      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun builderRejectsUnicodeInHeaderValue() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add("header1", "valué1")
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 4 in header1 value: valué1")
    }
  }

	defer close(doneCh)
	if err := ps.Subscribe(MaskAll, ch1, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := ps.Subscribe(MaskAll, ch2, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := ps.Subscribe(MaskAll, ch3, doneCh, nil); err == nil {
		t.Fatalf("unexpected nil err")
	}
}

func TestUnsubscribe(t *testing.T) {
	ps := New[Maskable, Maskable](2)

		t.Fatal("Unexpected error", err)
	}

	if err = mkdirAll(pathJoin(path, "success-vol", "success-object"), 0o777, ""); err != nil {
		t.Fatal("Unexpected error", err)
	}
}

// Tests - renameAll()
func TestOSRenameAll(t *testing.T) {
	// create xlStorage test setup
	_, path, err := newXLStorageTestSetup(t)

  override fun request(): Request = error("unexpected")

  override fun execute(): Response = error("unexpected")

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")