From 53ac4a1cbde45e1eba0ccd736667bbec8d7c73ce Mon Sep 17 00:00:00 2001 From: Claudio Maggioni Date: Mon, 17 Apr 2023 16:33:47 +0200 Subject: [PATCH] ga6 almost done --- SQ-2023-H6/pom.xml | 139 +++++++++ .../org/usi/sq/util/CircularFifoQueue.java | 276 ++++++++++++++++++ .../usi/sq/util/CircularFifoQueueTest.java | 89 ++++++ 3 files changed, 504 insertions(+) create mode 100644 SQ-2023-H6/pom.xml create mode 100644 SQ-2023-H6/src/main/java/org/usi/sq/util/CircularFifoQueue.java create mode 100644 SQ-2023-H6/src/test/java/org/usi/sq/util/CircularFifoQueueTest.java diff --git a/SQ-2023-H6/pom.xml b/SQ-2023-H6/pom.xml new file mode 100644 index 0000000..acd2026 --- /dev/null +++ b/SQ-2023-H6/pom.xml @@ -0,0 +1,139 @@ + + + 4.0.0 + org.usi.sq + SQ-2023-H6 + 1.0 + + UTF-8 + 1.7.0-M1 + 5.6.2 + 5.6.2 + 4.13 + + + + + central + https://repo.maven.apache.org/maven2 + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0-M5 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 8 + 8 + + + + org.jacoco + jacoco-maven-plugin + 0.8.5 + + + + prepare-agent + + + + + report + test + + report + + + + + + org.pitest + pitest-maven + 1.5.2 + + + org.usi.sq.util* + + + org.usi.sq.util* + * + + + + + + org.pitest + pitest-junit5-plugin + 0.12 + + + + + + + + org.junit.jupiter + junit-jupiter-api + ${junit.jupiter.version} + test + + + org.junit.jupiter + junit-jupiter-engine + ${junit.jupiter.version} + test + + + junit + junit + ${junit.version} + test + + + org.junit.vintage + junit-vintage-engine + ${junit.vintage.version} + test + + + + + + org.jacoco + jacoco-maven-plugin + 0.8.5 + + + + + report + + + + + + org.apache.maven.plugins + maven-surefire-report-plugin + 3.0.0-M5 + + + + + + org.apache.maven.plugins + maven-jxr-plugin + 3.3.0 + + + + diff --git a/SQ-2023-H6/src/main/java/org/usi/sq/util/CircularFifoQueue.java b/SQ-2023-H6/src/main/java/org/usi/sq/util/CircularFifoQueue.java new file mode 100644 index 0000000..a6b2001 --- /dev/null +++ b/SQ-2023-H6/src/main/java/org/usi/sq/util/CircularFifoQueue.java @@ -0,0 +1,276 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.usi.sq.util; + +import java.io.Serializable; +import java.util.*; + +/** + * CircularFifoQueue is a first-in first-out queue with a fixed size that + * replaces its oldest element if full. + *

+ * The removal order of a {@link CircularFifoQueue} is based on the + * insertion order; elements are removed in the same order in which they + * were added. The iteration order is the same as the removal order. + *

+ *

+ * This queue prevents null objects from being added. + *

+ * + * @param the type of elements in this collection + * @since 4.0 + */ +public class CircularFifoQueue { + + /** Serialization version. */ + private static final long serialVersionUID = -8423413834657610406L; + + /** Underlying storage array. */ + private transient E[] elements; + + /** Array index of first (oldest) queue element. */ + private transient int start = 0; + + /** + * Index mod maxElements of the array position following the last queue + * element. Queue elements start at elements[start] and "wrap around" + * elements[maxElements-1], ending at elements[decrement(end)]. + * For example, elements = {c,a,b}, start=1, end=1 corresponds to + * the queue [a,b,c]. + */ + private transient int end = 0; + + /** Flag to indicate if the queue is currently full. */ + private transient boolean full = false; + + /** Capacity of the queue. */ + private final int maxElements; + + /** + * Constructor that creates a queue with the default size of 32. + */ + public CircularFifoQueue() { + this(32); + } + + /** + * Constructor that creates a queue with the specified size. + * + * @param size the size of the queue (cannot be changed) + * @throws IllegalArgumentException if the size is < 1 + */ + @SuppressWarnings("unchecked") + public CircularFifoQueue(final int size) { + if (size <= 0) { + throw new IllegalArgumentException("The size must be greater than 0"); + } + elements = (E[]) new Object[size]; + maxElements = elements.length; + } + + /** + * Returns {@code true} if the capacity limit of this queue has been reached, + * i.e. the number of elements stored in the queue equals its maximum size. + * + * @return {@code true} if the capacity limit has been reached, {@code false} otherwise + * @since 4.1 + */ + public boolean isAtFullCapacity() { + return size() == maxElements; + } + + /** + * Adds the given element to this queue. If the queue is full, the least recently added + * element is discarded so that a new element can be inserted. + * + * @param element the element to add + * @return true, always + * @throws NullPointerException if the given element is null + */ + public boolean add(final E element) { + if (null == element) { + throw new NullPointerException("Attempted to add null object to queue"); + } + + if (isAtFullCapacity()) { + remove(); + } + + elements[end++] = element; + + if (end >= maxElements) { + end = 0; + } + + if (end == start) { + full = true; + } + + return true; + } + + /** + * Adds the given element to this queue. If the queue is full, the least recently added + * element is discarded so that a new element can be inserted. + * + * @param element the element to add + * @return true, always + * @throws NullPointerException if the given element is null + */ + public boolean offer(final E element) { + return add(element); + } + + /** + * Increments the internal index. + * + * @param index the index to increment + * @return the updated index + */ + private int increment(int index) { + index++; + if (index >= maxElements) { + index = 0; + } + return index; + } + + /** + * Decrements the internal index. + * + * @param index the index to decrement + * @return the updated index + */ + private int decrement(int index) { + index--; + if (index < 0) { + index = maxElements - 1; + } + return index; + } + + /** + * Returns true if this queue is empty; false otherwise. + * + * @return true if this queue is empty + */ + public boolean isEmpty() { + return size() == 0; + } + + public E remove() { + if (isEmpty()) { + throw new NoSuchElementException("queue is empty"); + } + + final E element = elements[start]; + if (null != element) { + elements[start++] = null; + + if (start >= maxElements) { + start = 0; + } + full = false; + } + return element; + } + + /** + * Returns the number of elements stored in the queue. + * + * @return this queue's size + */ + public int size() { + int size = 0; + + if (end < start) { + size = maxElements - start + end; + } else if (end == start) { + size = full ? maxElements : 0; + } else { + size = end - start; + } + + return size; + } + + + /** + * Returns an iterator over this queue's elements. + * + * @return an iterator over this queue's elements + */ + public Iterator iterator() { + return new Iterator() { + + private int index = start; + private int lastReturnedIndex = -1; + private boolean isFirst = full; + + public boolean hasNext() { + return isFirst || index != end; + } + + public E next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + isFirst = false; + lastReturnedIndex = index; + index = increment(index); + return elements[lastReturnedIndex]; + } + + public void remove() { + if (lastReturnedIndex == -1) { + throw new IllegalStateException(); + } + + // First element can be removed quickly + if (lastReturnedIndex == start) { + CircularFifoQueue.this.remove(); + lastReturnedIndex = -1; + return; + } + + int pos = lastReturnedIndex + 1; + if (start < lastReturnedIndex && pos < end) { + // shift in one part + System.arraycopy(elements, pos, elements, lastReturnedIndex, end - pos); + } else { + // Other elements require us to shift the subsequent elements + while (pos != end) { + if (pos >= maxElements) { + elements[pos - 1] = elements[0]; + pos = 0; + } else { + elements[decrement(pos)] = elements[pos]; + pos = increment(pos); + } + } + } + + lastReturnedIndex = -1; + end = decrement(end); + elements[end] = null; + full = false; + index = decrement(index); + } + + }; + } +} diff --git a/SQ-2023-H6/src/test/java/org/usi/sq/util/CircularFifoQueueTest.java b/SQ-2023-H6/src/test/java/org/usi/sq/util/CircularFifoQueueTest.java new file mode 100644 index 0000000..264e6de --- /dev/null +++ b/SQ-2023-H6/src/test/java/org/usi/sq/util/CircularFifoQueueTest.java @@ -0,0 +1,89 @@ +package org.usi.sq.util; + +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class CircularFifoQueueTest { + + private void testIteratorEmpty(Iterator it) { + assertFalse(it.hasNext()); + assertThrows(NoSuchElementException.class, it::next); + } + + private void testIteratorNext(Iterator it, T e) { + assertTrue(it.hasNext()); + assertEquals(e, it.next()); + } + + private void testQueueAll(int initQueueSize, List values, long removeQueueCount, List itrRemoveIndexes) { + final Set removeIndexesSet = new HashSet<>(itrRemoveIndexes); + + final CircularFifoQueue queue = new CircularFifoQueue<>(initQueueSize); + for (T e : values) assertTrue(queue.offer(e)); + + int queueSizeAfterOffers = Math.min(initQueueSize, values.size()); + for (int i = 0; i < removeQueueCount; i++) { + assertEquals(values.get(values.size() - queueSizeAfterOffers + i), queue.remove()); + } + + assertEquals(queueSizeAfterOffers - removeQueueCount, queue.size()); + assertEquals(queue.size() == initQueueSize, queue.isAtFullCapacity()); + + final Iterator it = queue.iterator(); + final List notRemovedValues = new ArrayList<>(values.size()); + + final List expected = values.subList(Math.max(0, values.size() - queue.size()), values.size()); + + // Test Iteration + for (int i = 0; i < expected.size(); i++) { + T e = expected.get(i); + testIteratorNext(it, e); + + if (removeIndexesSet.contains(i)) { + it.remove(); + assertThrows(IllegalStateException.class, it::remove); // removing again causes explosion + } else { + notRemovedValues.add(e); + } + } + testIteratorEmpty(it); + + // Test removal + assertEquals(notRemovedValues.size(), queue.size()); + final Iterator itNew = queue.iterator(); + for (T e : notRemovedValues) testIteratorNext(itNew, e); + testIteratorEmpty(itNew); + } + + + + + @Test + public void testIterator() { + assertThrows(IllegalArgumentException.class, () -> new CircularFifoQueue(0)); + assertThrows(NoSuchElementException.class, () -> new CircularFifoQueue().remove()); + assertThrows(NullPointerException.class, () -> new CircularFifoQueue().offer(null)); + + testQueueIteratorRemove(10, Arrays.asList(1, 2, 3), 0, 2); + testQueueIteratorRemove(3, Arrays.asList(1, 2, 3), 0, 2); + testQueueIteratorRemove(3, Arrays.asList(1, 2, 3), 0, 2); + testQueueIteratorRemove(2, Arrays.asList(1, 2, 3)); + testQueueIteratorRemove(4, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9), 1, 3); + testQueueAll(7, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), 4, Arrays.asList(1, 3)); + + testQueueIteratorRemove(4, Arrays.asList(1, 2, 3, 4, 5), 1, 3); + testQueueIteratorRemove(10, Collections.emptyList()); + testQueueQueueRemove(4, Arrays.asList(1, 2, 3, 4, 5), 1); + } + + private void testQueueQueueRemove(int i, List asList, int i1) { + testQueueAll(i, asList, i1, Collections.emptyList()); + } + + private void testQueueIteratorRemove(int i, List asList, Integer... asList1) { + testQueueAll(i, asList, 0, Arrays.asList(asList1)); + } +}