return true;
      }
      if (object instanceof DoubleArrayAsList) {
        DoubleArrayAsList that = (DoubleArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

    // When called at high frequency, boxing size generates too much garbage,
    // so avoid doing that if we can.
    if (size < 0) {
      throw new IllegalArgumentException(String.format("Invalid size: %s", size));
    }
    return newDataOutput(new ByteArrayOutputStream(size));
  }

  /**
   * Returns a new {@link ByteArrayDataOutput} instance which writes to the given {@code

    }

    /**
     * @throws Exception
     */
    @Test
    public void testSize() throws Exception {
        assertThat(list.size(), is(0));
        list.addLast("1");
        assertThat(list.size(), is(1));
        list.removeFirst();
        assertThat(list.size(), is(0));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIsEmpty() throws Exception {

   * size.
   *
   * @param chunkSize the number of bytes available per {@link #process(ByteBuffer)} invocation;
   *     must be at least 4
   */
  protected AbstractStreamingHasher(int chunkSize) {
    this(chunkSize, chunkSize);
  }

  /**
   * Constructor for use by subclasses. This hasher instance will process chunks of the specified

	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "LastHour"
	o = append(o, 0x84, 0xa8, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x75, 0x72)
	o, err = z.LastHour.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "LastHour")
		return
	}
	// string "SinceUptime"
	o = append(o, 0xab, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x55, 0x70, 0x74, 0x69, 0x6d, 0x65)
	// map header, size 2
	// string "Count"

        if (list.contains(key)) {
          assertEquals(list.indexOf(key) - 1, answer);
          return;
        }
        break;
    }
    // key is not present
    int nextHigherIndex = list.size();
    for (int i = list.size() - 1; i >= 0 && list.get(i) > key; i--) {
      nextHigherIndex = i;
    }
    switch (absentBehavior) {
      case NEXT_LOWER:
        assertEquals(nextHigherIndex - 1, answer);
        return;

        bufferIndex += nsalt;

        return bufferIndex - start;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size () {
        return 4 + ( this.hashAlgos != null ? 2 * this.hashAlgos.length : 0 ) + ( this.salt != null ? this.salt.length : 0 );
    }

        buf.enc_ndr_long(2); /* syntax version */
    }


    @Override
    public void decode_out ( NdrBuffer buf ) throws NdrException {
        buf.dec_ndr_short(); /* max transmit frag size */
        buf.dec_ndr_short(); /* max receive frag size */
        buf.dec_ndr_long(); /* assoc. group */
        int n = buf.dec_ndr_short(); /* secondary addr len */
        buf.advance(n); /* secondary addr */
        buf.align(4);

        SMBUtil.writeInt4(this.lengthInBytes, dst, dstIndex + 6);
        return 10;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size () {
        return this.largeFile ? 20 : 10;
    }

			}
		})
	}
}

func TestBatchJobSizeValidate(t *testing.T) {
	errInvalidBatchJobSizeFilter := BatchJobYamlErr{
		msg: "invalid batch-job size filter",
	}

	tests := []struct {
		sizeFilter BatchJobSizeFilter
		err        error
	}{
		{
			// Unspecified size filter is a valid filter
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 0,
				LowerBound: 0,
			},
			err: nil,
		},
		{