if (removed != null) {
            log.debug("Mock unregistered witness: {}", registrationId);
            return true;
        }
        return false;
    }

    /**
     * Get the number of active registrations
     *
     * @return the registration count
     */
    public int getRegistrationCount() {
        return registrations.size();
    }

    /**

        assertEquals(incremental, artifactVersion.getIncrementalVersion(), parsed + "check incremental version");
        assertEquals(buildnumber, artifactVersion.getBuildNumber(), parsed + "check build number");
        assertEquals(qualifier, artifactVersion.getQualifier(), parsed + "check qualifier");
        assertEquals(version, artifactVersion.toString(), "check " + version + " string value");
    }

    @Test

   * allocated, the value of {@code metadata} combines the number of bits in the "short hash", in
   * its bottom {@value CompactHashing#HASH_TABLE_BITS_MAX_BITS} bits, with a modification count in
   * the remaining bits that is used to detect concurrent modification during iteration.
   */
  private transient int metadata;

  /** The number of elements contained in the set. */
  private transient int size;

		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z ActiveWorkerStat) Msgsize() (s int) {
	s = 1 + 5 + msgp.IntSize + 4 + msgp.Float32Size + 4 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable

        final String s = props.getProperty(key);
        if (s != null) {
            try {
                def = Integer.parseInt(s);
            } catch (final NumberFormatException nfe) {
                log.error("Not a number", nfe);
            }
        }
        return def;
    }

    /**
     * Retrieve an <code>int</code>. If the property is not found, <code>-1</code> is returned.
     *

     *
     * @param b the buffer into which the data is read
     * @param off the start offset in the array b at which the data is written
     * @param len the maximum number of bytes to read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = rebalSaveOpts(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z rebalSaveOpts) Msgsize() (s int) {
	s = msgp.Uint8Size
	return
}

// DecodeMsg implements msgp.Decodable

	d, err := Open(dirPath)
	if err != nil {
		if osErrToFileErr(err) == errFileNotFound {
			return nil
		}
		return osErrToFileErr(err)
	}
	defer d.Close()

	maxEntries := 1000
	for {
		// Read up to max number of entries.
		fis, err := d.Readdir(maxEntries)
		if err != nil {
			if err == io.EOF {
				break
			}
			err = osErrToFileErr(err)
			if err == errFileNotFound {
				return nil
			}
			return err
		}

            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Sets the maximum number of rows.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @param maxRows
     *            Maximum number of rows.
     * @see Statement#setMaxRows(int)
     */
    public static void setMaxRows(final Statement statement, final int maxRows) {

			errCode = ErrInvalidMaxParts
			return
		}
	} else {
		maxParts = maxPartsList
	}

	if values.Get("part-number-marker") != "" {
		if partNumberMarker, err = strconv.Atoi(values.Get("part-number-marker")); err != nil {
			errCode = ErrInvalidPartNumberMarker
			return
		}
	}

	uploadID = values.Get("uploadId")
	encodingType = values.Get("encoding-type")