/*=============================================================================#
 # Copyright (c) 2020, 2021 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.jcommons.collections;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

import static org.eclipse.statet.jcommons.collections.CollectionTests.A_notIdentical;
import static org.eclipse.statet.jcommons.collections.CollectionTests.B_notIdentical;

import java.util.Arrays;
import java.util.Set;

import org.junit.jupiter.api.Test;

import org.eclipse.statet.jcommons.lang.NonNullByDefault;


@NonNullByDefault
public abstract class AbstractMutableSetTest<T extends Set<String>> extends AbstractSetTest<T> {
	
	
	public AbstractMutableSetTest(final Class<?> type) {
		super(type);
	}
	
	
	@Test
	public void add() {
		boolean r;
		
		this.c= createEmptyCollection();
		assertCollectionEmpty();
		
		r= this.c.add("A");
		assertCollectionEquals("A");
		assertTrue(r);
		
		r= this.c.add("B");
		assertCollectionEquals("A", "B");
		assertTrue(r);
		
		r= this.c.add("A");
		assertCollectionEquals("A", "B");
		assertFalse(r);
	}
	
	@Test
	public void add_notIdentical() {
		boolean r;
		
		this.c= createCollection("A", "B");
		assertCollectionEquals("A", "B");
		
		r= this.c.add(A_notIdentical);
		if (this.isIdentityCollection) {
			assertCollectionEquals("A", "B", A_notIdentical);
			assertTrue(r);
		}
		else {
			assertCollectionEquals("A", "B");
			assertFalse(r);
		}
	}
	
	@Test
	public void addAll() {
		boolean r;
		
		this.c= createEmptyCollection();
		assertCollectionEmpty();
		
		r= this.c.addAll(Arrays.asList("A", "B"));
		assertCollectionEquals("A", "B");
		assertTrue(r);
		
		r= this.c.addAll(Arrays.asList("A", "B"));
		assertCollectionEquals("A", "B");
		assertFalse(r);
		
		r= this.c.addAll(Arrays.asList("C", "D"));
		assertCollectionEquals("A", "B", "C", "D");
		assertTrue(r);
		
		r= this.c.addAll(Arrays.asList());
		assertCollectionEquals("A", "B", "C", "D");
		assertFalse(r);
		
		r= this.c.addAll(Arrays.asList("A", "B", "E", "F", "A", "B", "E", "F"));
		assertCollectionEquals("A", "B", "C", "D", "E", "F");
		assertTrue(r);
	}
	
	@Test
	public void addAll_notIdentical() {
		boolean r;
		
		this.c= createCollection("A", "B");
		
		r= this.c.addAll(Arrays.asList(A_notIdentical, B_notIdentical));
		if (this.isIdentityCollection) {
			assertCollectionEquals("A", "B", A_notIdentical, B_notIdentical);
			assertTrue(r);
		}
		else {
			assertCollectionEquals("A", "B");
			assertFalse(r);
		}
	}
	
	@Test
	public void retainAll() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("B", "C", "D"));
		assertCollectionEquals("B", "C", "D");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("X", "B", "C", "C", "D", "X"));
		assertCollectionEquals("B", "C", "D");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("D", "C", "A"));
		assertCollectionEquals("A", "C", "D");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("A"));
		assertCollectionEquals("A");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("F"));
		assertCollectionEquals("F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("X"));
		assertCollectionEmpty();
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList());
		assertCollectionEmpty();
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList("F", "B", "C", "D", "E", "A"));
		assertCollectionEquals("A", "B", "C", "D", "E", "F");
		assertFalse(r);
	}
	
	@Test
	public void retainAll_notIdentical() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.retainAll(Arrays.asList(A_notIdentical, "B", B_notIdentical, "D"));
		if (this.isIdentityCollection) {
			assertCollectionEquals("B", "D");
			assertTrue(r);
		}
		else {
			assertCollectionEquals("A", "B", "D");
			assertTrue(r);
		}
	}
	
	@Test
	public void remove() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove("B");
		assertCollectionEquals("A", "C", "D", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove("A");
		assertCollectionEquals("B", "C", "D", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove("F");
		assertCollectionEquals("A", "B", "C", "D", "E");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove("X");
		assertCollectionEquals("A", "B", "C", "D", "E", "F");
		assertFalse(r);
		
		this.c= createCollection("A");
		r= this.c.remove("A");
		assertCollectionEmpty();
		assertTrue(r);
		
		r= this.c.remove("X");
		assertCollectionEmpty();
		assertFalse(r);
	}
	
	@Test
	public void remove_notIdentical() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove(B_notIdentical);
		if (this.isIdentityCollection) {
			assertCollectionEquals("A", "B", "C", "D", "E", "F");
			assertFalse(r);
		}
		else {
			assertCollectionEquals("A", "C", "D", "E", "F");
			assertTrue(r);
		}
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.remove(A_notIdentical);
		if (this.isIdentityCollection) {
			assertCollectionEquals("A", "B", "C", "D", "E", "F");
			assertFalse(r);
		}
		else {
			assertCollectionEquals("B", "C", "D", "E", "F");
			assertTrue(r);
		}
	}
	
	@Test
	public void removeAll() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("B", "C", "D"));
		assertCollectionEquals("A", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("X", "B", "C", "C", "D", "X"));
		assertCollectionEquals("A", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("D", "C", "A"));
		assertCollectionEquals("B", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("A"));
		assertCollectionEquals("B", "C", "D", "E", "F");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("F"));
		assertCollectionEquals("A", "B", "C", "D", "E");
		assertTrue(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("X"));
		assertCollectionEquals("A", "B", "C", "D", "E", "F");
		assertFalse(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList());
		assertCollectionEquals("A", "B", "C", "D", "E", "F");
		assertFalse(r);
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList("A", "B", "C", "D", "E", "F"));
		assertCollectionEmpty();
		assertTrue(r);
		
		this.c= createCollection("A");
		r= this.c.removeAll(Arrays.asList("A", "B", "C", "D", "E", "F"));
		assertCollectionEmpty();
		assertTrue(r);
	}
	
	@Test
	public void removeAll_notIdentical() {
		boolean r;
		
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		r= this.c.removeAll(Arrays.asList(A_notIdentical, "B", B_notIdentical, "D"));
		if (this.isIdentityCollection) {
			assertCollectionEquals("A", "C", "E", "F");
			assertTrue(r);
		}
		else {
			assertCollectionEquals("C", "E", "F");
			assertTrue(r);
		}
	}
	
	@Test
	public void clear() {
		this.c= createCollection("A", "B", "C", "D", "E", "F");
		this.c.clear();
		assertCollectionEmpty();
		
		this.c.clear();
		assertCollectionEmpty();
	}
	
}