assertEquals(length, SMBUtil.readInt4(buffer, startIndex + 16));

            // Verify reserved bytes are zeros
            for (int i = 0; i < RESERVED_BYTES; i++) {
                assertEquals(0, buffer[startIndex + 20 + i]);
            }
        }

        @Test
        @DisplayName("Should encode zero values correctly")
        void testEncodeZeroValues() {
            // Given

                    PluginExecution existing = merged.get(key);
                    if (existing != null) {
                        mergePluginExecution(element, existing, sourceDominant, context);
                    }
                    merged.put(key, element);
                }

                target.setExecutions(new ArrayList<>(merged.values()));
            }
        }
    }

            List<ToolchainModel> dominant, List<ToolchainModel> recessive, String recessiveSourceLevel) {
        Map<Object, ToolchainModel> merged = new LinkedHashMap<>();

        for (ToolchainModel dominantModel : dominant) {
            Object key = getToolchainModelKey(dominantModel);

            merged.put(key, dominantModel);
        }

        for (ToolchainModel recessiveModel : recessive) {

        Properties merged = new Properties();
        if (sourceDominant) {
            merged.putAll(target.getProperties());
            merged.putAll(source.getProperties());
        } else {
            merged.putAll(source.getProperties());
            merged.putAll(target.getProperties());
        }
        target.setProperties(merged);
        target.setLocation(

     * key on an absent value should result in a single call to either {@code recordLoadSuccess} or
     * {@code recordLoadException} and multiple calls to this method, despite all being served by
     * the results of a single load operation.
     *
     * @param count the number of misses to record
     * @since 11.0
     */
    void recordMisses(int count);

    /**

        SuggestItem merged = SuggestItem.merge(item1, item2);

        assertNotNull(merged);
        assertEquals("item1", merged.getText());
        assertEquals(150L, merged.getQueryFreq()); // Sum of frequencies
        assertEquals(75L, merged.getDocFreq()); // Sum of frequencies
        assertEquals(1.5f, merged.getUserBoost(), 0.001f); // Takes item2's boost

            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;
        } catch (Exception e) {
            throw new RepositoryException(e.getMessage(), e);
        }
    }

    @Override
    public boolean isMerged() {
        return merged;
    }

    @Override
    public String getGroupId() {
        return emptify(metadata.getGroupId());
    }

			merged = append(merged, b[0])
			b = b[1:]
		}
		if limit > 0 && len(merged) >= limit {
			break
		}
	}
	// Append anything left.
	if limit < 0 || len(merged) < limit {
		merged = append(merged, a...)
		merged = append(merged, b...)
	}
	m.o = merged
}

// filterPrefix will filter m to only contain entries with the specified prefix.
func (m *metaCacheEntriesSorted) filterPrefix(s string) {

   * it is returned directly. Otherwise, a new array of size {@code minLength + padding} is
   * returned, containing the values of {@code array}, and zeroes in the remaining places.
   *
   * @param array the source array
   * @param minLength the minimum length the returned array must guarantee
   * @param padding an extra amount to "grow" the array by if growth is necessary

        new SecureRandom().nextBytes(data);

        // Verify data is not all zeros initially
        boolean hasNonZero = false;
        for (byte b : data) {
            if (b != 0) {
                hasNonZero = true;
                break;
            }
        }
        assertTrue(hasNonZero, "Data should have non-zero bytes");

        SecureKeyManager.secureWipe(data);

        // Verify data is wiped