super(message);
        this.type = type;
    }

    /**
     * Returns the type of the invalid access token.
     *
     * @return the type of the invalid access token
     */
    public String getType() {
        return type;
    }

        }
        try (FileReader reader = new FileReader(file)) {
            List<UpgradedProperty> upgradedProperties = new Gson().fromJson(reader, new TypeToken<List<UpgradedProperty>>() {}.getType());
            // FIXME There should be no duplicates, yet there are some
            return upgradedProperties.stream()
                .distinct()
                .collect(ImmutableList.toImmutableList());

        request.addFlags0(0x16);
        response.setExtended(true);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbFile#getType()
     */
    @Override
    public int getType() throws SmbException {
        return TYPE_NAMED_PIPE;
    }

    /**
     * @return the pipe type
     */
    @Override
    public int getPipeType() {

                .version(dependency.getVersion().toString())
                .classifier(dependency.getClassifier())
                .extension(dependency.getExtension())
                .type(dependency.getType().id())
                .scope(dependency.getScope().id())
                .optional(dependency.isOptional())
                .build();
    }

    @Nonnull

        response.getServerData().scapabilities = 0;
        response.getServerData().encryptionKeyLength = 8;
        // Domain name in OEM encoding (ASCII) with null terminator
        byte[] domainBytes = "DOMAIN\0".getBytes("US-ASCII");
        // Use reflection to set protected byteCount field
        int byteCountValue = 8 + domainBytes.length;
        setByteCount(response, byteCountValue);
        byte[] buffer = new byte[byteCountValue];

     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param is the input stream (must not be {@literal null})
     * @return the byte array
     */
    public static final byte[] getBytes(final InputStream is) {
        assertArgumentNotNull("is", is);

        final ByteArrayOutputStream os = new ByteArrayOutputStream(BUF_SIZE);
        CopyUtil.copy(is, os);
        return os.toByteArray();
    }

    /**
     * Context name for durable handle V2 response
     */
    public static final String CONTEXT_NAME = "DH2Q";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

    private long timeout100Ns; // timeout in 100-nanosecond intervals (wire format, unsigned 32-bit)
    private int flags;

    /**
     * Create a new durable handle V2 response
     */

      } else {
        suite.addTest(
            suiteForBytes(factory, entry.getValue().getBytes(UTF_8), name, entry.getKey(), true));
      }
    }
    return suite;
  }

  static TestSuite suiteForString(
      ByteSourceFactory factory, String string, String name, String desc) {
    TestSuite suite = suiteForBytes(factory, string.getBytes(UTF_8), name, desc, true);

  private boolean outputStreamOpened;
  private boolean outputStreamClosed;

  public TestByteSink(TestOption... options) {
    this.options = ImmutableSet.copyOf(options);
  }

  byte[] getBytes() {
    return bytes.toByteArray();
  }

  @Override
  public boolean wasStreamOpened() {
    return outputStreamOpened;
  }

  @Override
  public boolean wasStreamClosed() {

    /**
     * Context name for durable handle reconnect response
     */
    public static final String CONTEXT_NAME = "DHnC";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

    // The response structure is empty (0 bytes) for reconnect
    // No data is returned in a successful reconnect response

    /**
     * Create a new durable handle reconnect response
     */