| /* |
| * 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.apache.sysds.test.functions.privacy; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Map; |
| |
| import org.apache.sysds.runtime.privacy.PrivacyConstraint.PrivacyLevel; |
| import org.apache.sysds.runtime.privacy.finegrained.DataRange; |
| import org.apache.sysds.runtime.privacy.finegrained.FineGrainedPrivacy; |
| import org.apache.sysds.runtime.privacy.finegrained.FineGrainedPrivacyList; |
| import org.apache.sysds.runtime.privacy.finegrained.FineGrainedPrivacyMap; |
| import org.junit.After; |
| import org.junit.Test; |
| import org.junit.runners.Parameterized; |
| import org.junit.runner.RunWith; |
| |
| @RunWith(Parameterized.class) |
| public class FineGrainedPrivacyTest { |
| |
| private FineGrainedPrivacy constraints; |
| |
| public FineGrainedPrivacyTest(FineGrainedPrivacy constraints){ |
| this.constraints = constraints; |
| } |
| |
| @Parameterized.Parameters |
| public static Collection<FineGrainedPrivacy[]> FineGrainedPrivacy(){ |
| return Arrays.asList(new FineGrainedPrivacy[][] { |
| {new FineGrainedPrivacyMap()}, |
| {new FineGrainedPrivacyList()} |
| }); |
| } |
| |
| @After |
| public void setConstraintsToNull(){ |
| constraints.removeAllConstraints(); |
| constraints = null; |
| } |
| |
| @Test |
| public void getPrivacyLevelSingleConstraintCompletelyInRangeTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevel(new DataRange(new long[]{4L,4L,7L}, new long[]{5L,5L,8L})); |
| assertTrue(outputMap.containsKey(inputDataRange)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelSingleConstraintInRangeTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevel(new DataRange(new long[]{1L,4L,7L}, new long[]{5L,5L,8L})); |
| assertTrue(outputMap.containsKey(inputDataRange)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelSingleConstraintNotInRangeTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevel(new DataRange(new long[]{0L,4L,7L}, new long[]{2L,5L,8L})); |
| assertFalse(outputMap.containsKey(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelMultiConstraintInRangeTest(){ |
| DataRange inputDataRange1 = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| DataRange inputDataRange2 = new DataRange(new long[]{10L,14L,12L}, new long[]{45L,23L,15L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange1, inputPrivacyLevel); |
| constraints.put(inputDataRange2, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevel(new DataRange(new long[]{4L,3L,8L}, new long[]{50L,55L,19L})); |
| assertTrue(outputMap.containsKey(inputDataRange1)); |
| assertTrue(outputMap.containsKey(inputDataRange2)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange1)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange2)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementSingleConstraintTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{4L,4L,7L}); |
| assertTrue(outputMap.containsKey(inputDataRange)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementOnLowerBoundSingleConstraintTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{3L,2L,7L}); |
| assertTrue(outputMap.containsKey(inputDataRange)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementOnUpperBoundSingleConstraintTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{5L,6L,9L}); |
| assertTrue(outputMap.containsKey(inputDataRange)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementSingleConstraintNotInRangeTest(){ |
| DataRange inputDataRange = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{7L,10L,1L}); |
| assertFalse(outputMap.containsKey(inputDataRange)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementDoubleConstraintInSingleTest(){ |
| DataRange inputDataRange1 = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| DataRange inputDataRange2 = new DataRange(new long[]{10L,14L,12L}, new long[]{45L,23L,15L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange1, inputPrivacyLevel); |
| constraints.put(inputDataRange2, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{21L,17L,13L}); |
| assertTrue("inputDataRange2 should be in outputMap since element is in the range", outputMap.containsKey(inputDataRange2)); |
| assertFalse("inputDataRange1 should not be in outputMap", outputMap.containsKey(inputDataRange1)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange2)); |
| } |
| |
| @Test |
| public void getPrivacyLevelOfElementDoubleConstraintInBothTest(){ |
| DataRange inputDataRange1 = new DataRange(new long[]{3L,2L,7L}, new long[]{5L,6L,9L}); |
| DataRange inputDataRange2 = new DataRange(new long[]{1,1L,8L}, new long[]{45L,23L,15L}); |
| PrivacyLevel inputPrivacyLevel = PrivacyLevel.Private; |
| constraints.put(inputDataRange1, inputPrivacyLevel); |
| constraints.put(inputDataRange2, inputPrivacyLevel); |
| Map<DataRange, PrivacyLevel> outputMap = constraints.getPrivacyLevelOfElement(new long[]{4L,4L,9L}); |
| assertTrue("inputDataRange2 should be in outputMap since element is in the range", outputMap.containsKey(inputDataRange2)); |
| assertTrue("inputDataRange1 should be in outputMap since element is in the range", outputMap.containsKey(inputDataRange1)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange2)); |
| assertEquals(inputPrivacyLevel, outputMap.get(inputDataRange1)); |
| } |
| |
| @Test |
| public void getDataRangesOfPrivacyLevelTest(){ |
| DataRange inputDataRange1 = new DataRange(new long[]{60L,30L,70L}, new long[]{90L,60L,150L}); |
| DataRange inputDataRange2 = new DataRange(new long[]{10,10L,18L}, new long[]{450L,230L,250L}); |
| DataRange inputDataRange3 = new DataRange(new long[]{300L,250L,740L}, new long[]{520L,630L,1090L}); |
| DataRange inputDataRange4 = new DataRange(new long[]{10,10L,10L}, new long[]{30L,40L,50L}); |
| PrivacyLevel inputPrivacyLevel1 = PrivacyLevel.Private; |
| PrivacyLevel inputPrivacyLevel2 = PrivacyLevel.PrivateAggregation; |
| constraints.put(inputDataRange1, inputPrivacyLevel1); |
| constraints.put(inputDataRange2, inputPrivacyLevel1); |
| constraints.put(inputDataRange3, inputPrivacyLevel2); |
| constraints.put(inputDataRange4, inputPrivacyLevel2); |
| DataRange[] outputDataRanges1 = constraints.getDataRangesOfPrivacyLevel(inputPrivacyLevel1); |
| assertEquals(inputDataRange1, outputDataRanges1[0]); |
| assertEquals(inputDataRange2, outputDataRanges1[1]); |
| DataRange[] outputDataRanges2 = constraints.getDataRangesOfPrivacyLevel(inputPrivacyLevel2); |
| assertEquals(inputDataRange3, outputDataRanges2[0]); |
| assertEquals(inputDataRange4, outputDataRanges2[1]); |
| } |
| } |