nassh_buffer_test_util.js

// Copyright 2020 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/**
 * @fileoverview Common buffer API tests.
 */

import {newBuffer, setDefaultBackend} from './nassh_buffer.js';
import {BufferInterface} from './nassh_buffer_interface.js';

/**
 * Helper class for inspecting buffer internals.
 *
 * @abstract
 */
export class BufferInspector {
  /**
   * @param {!BufferInterface} buffer The buffer to inspect.
   */
  constructor(buffer) {
    this.buffer = buffer;
  }

  /**
   * How many bytes not yet acked.
   *
   * @abstract
   * @return {number}
   */
  getUnackedCount() {}
}

/**
 * This is mocha.Context with extra stuff attached.
 *
 * @typedef {{
 *   skip: function(),
 *   backend: string,
 *   inspectClass: !typeof BufferInspector,
 * }}
 */
let BufferContext;

/**
 * Check behavior of empty buffers.
 *
 * @this {!BufferContext}
 */
function testBufferEmpty() {
  setDefaultBackend(this.backend);
  const buffer = newBuffer();

  // No data available.
  assert.equal(0, buffer.getUnreadCount());
  // Read data that doesn't exist.
  const data = buffer.read(100);
  // The buffer should be empty.
  assert.equal(0, data.length);
  assert.deepStrictEqual(new Uint8Array(0), data);
  // Internal length should be still be zero.
  assert.equal(0, buffer.getUnreadCount());
  // Acking data that doesn't exist shouldn't confuse it.
  buffer.ack(10);
  assert.equal(0, buffer.getUnreadCount());
}

/**
 * Check autoacking behavior.
 *
 * @this {!BufferContext}
 * @suppress {checkTypes} Closure can't figure out abstract class.
 */
function testBufferAutoack() {
  setDefaultBackend(this.backend);
  const buffer = newBuffer(/* autoack= */ true);
  const inspector = new this.inspectClass(buffer);

  // Write some data to the buffer.
  buffer.write(new Uint8Array([1, 2]));
  buffer.write(new Uint8Array([3]));
  // Make sure our counters are correct.
  assert.equal(3, buffer.getUnreadCount());
  assert.equal(3, inspector.getUnackedCount());

  // Read out a byte and check the counters.
  let data = buffer.read(1);
  assert.deepStrictEqual(new Uint8Array([1]), data);
  assert.equal(2, buffer.getUnreadCount());
  assert.equal(2, inspector.getUnackedCount());

  // Read out the rest of the data and check the counters.
  data = buffer.read(2);
  assert.deepStrictEqual(new Uint8Array([2, 3]), data);
  assert.equal(0, buffer.getUnreadCount());
  assert.equal(0, inspector.getUnackedCount());
}

/**
 * Check manual acking behavior.
 *
 * @this {!BufferContext}
 * @suppress {checkTypes} Closure can't figure out abstract class.
 */
function testBufferManualAck() {
  setDefaultBackend(this.backend);
  const buffer = newBuffer();
  const inspector = new this.inspectClass(buffer);

  // Write some data to the buffer.
  buffer.write(new Uint8Array([5, 6, 7]));
  assert.equal(3, buffer.getUnreadCount());

  // Read it out and verify the ack counts.
  buffer.read(1);
  assert.equal(2, buffer.getUnreadCount());
  assert.equal(3, inspector.getUnackedCount());

  // Read out the rest of the data and check the counters.
  buffer.read(2);
  assert.equal(0, buffer.getUnreadCount());
  assert.equal(3, inspector.getUnackedCount());

  // Check ack handling.
  buffer.ack(1);
  assert.equal(2, inspector.getUnackedCount());
  buffer.ack(2);
  assert.equal(0, inspector.getUnackedCount());
}

/**
 * Check automatic buffer growing.
 *
 * @this {!BufferContext}
 * @suppress {checkTypes} Closure can't figure out abstract class.
 */
function testBufferGrow() {
  setDefaultBackend(this.backend);
  const buffer = newBuffer();
  const inspector = new this.inspectClass(buffer);
  const basesize = 1024;

  // Fill the buffer.
  buffer.write(new Uint8Array(basesize).fill(10));
  assert.equal(basesize, buffer.getUnreadCount());

  // Add some more data and check the growth.
  buffer.write(new Uint8Array([1, 2, 3]));
  assert.equal(basesize + 3, buffer.getUnreadCount());

  // Read out most data to verify buffer doesn't move.
  assert.deepStrictEqual(new Uint8Array(basesize).fill(10),
                         buffer.read(basesize));
  assert.equal(3, buffer.getUnreadCount());

  // Write some more data to check more growth.
  buffer.write(new Uint8Array(1024).fill(20));
  assert.equal(1027, buffer.getUnreadCount());

  // Read out all the data.
  assert.deepStrictEqual(new Uint8Array([1, 2, 3]), buffer.read(3));
  assert.deepStrictEqual(new Uint8Array(1024).fill(20), buffer.read(1024));

  // Counters shouldn't change even as we ack.
  assert.equal(0, buffer.getUnreadCount());
  assert.equal(basesize + 1027, inspector.getUnackedCount());
  buffer.ack(basesize + 1027);
  assert.equal(0, inspector.getUnackedCount());
}

/**
 * Testsuite for the generic buffer API.
 *
 * Each implementation should call this to verify functionality.
 *
 * @param {string} backend The name of the backend to instantiate.
 * @param {!typeof BufferInspector} inspectClass Class for inspecting the
 *     buffer internals while testing.
 */
export function BufferApiTest(backend, inspectClass) {
  before(function() {
    this.backend = backend;
    this.inspectClass = inspectClass;
  });
  it('buffer-empty', testBufferEmpty);
  it('buffer-autoack', testBufferAutoack);
  it('buffer-manual-ack', testBufferManualAck);
  it('buffer-grow', testBufferGrow);
}