| /* 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.harmony.nio.tests.java.nio.channels.spi; |
| |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| import java.io.IOException; |
| import java.nio.channels.DatagramChannel; |
| import java.nio.channels.Pipe; |
| import java.nio.channels.SelectionKey; |
| import java.nio.channels.Selector; |
| import java.nio.channels.ServerSocketChannel; |
| import java.nio.channels.SocketChannel; |
| import java.nio.channels.spi.AbstractSelectableChannel; |
| import java.nio.channels.spi.AbstractSelectionKey; |
| import java.nio.channels.spi.SelectorProvider; |
| import java.nio.channels.spi.AbstractSelector; |
| import java.util.Set; |
| |
| import junit.framework.TestCase; |
| @TestTargetClass(AbstractSelector.class) |
| /** |
| * Tests for AbstractSelector and register of its default implementation |
| */ |
| public class AbstractSelectorTest extends TestCase { |
| |
| /** |
| * @tests AbstractSelector#provider() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "provider", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "AbstractSelector", |
| args = {SelectorProvider.class} |
| ) |
| }) |
| public void test_provider() throws IOException { |
| Selector mockSelector = new MockAbstractSelector(SelectorProvider |
| .provider()); |
| assertTrue(mockSelector.isOpen()); |
| assertSame(SelectorProvider.provider(), mockSelector.provider()); |
| mockSelector = new MockAbstractSelector(null); |
| assertNull(mockSelector.provider()); |
| } |
| |
| /** |
| * @tests AbstractSelector#close() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "close", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "implCloseSelector", |
| args = {} |
| ) |
| }) |
| public void test_close() throws IOException { |
| MockAbstractSelector mockSelector = new MockAbstractSelector( |
| SelectorProvider.provider()); |
| mockSelector.close(); |
| assertTrue(mockSelector.isImplCloseSelectorCalled); |
| } |
| |
| /** |
| * |
| * @tests AbstractSelector#begin/end() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "begin", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "end", |
| args = {} |
| ) |
| }) |
| public void test_begin_end() throws IOException { |
| MockAbstractSelector mockSelector = new MockAbstractSelector( |
| SelectorProvider.provider()); |
| try { |
| mockSelector.superBegin(); |
| } finally { |
| mockSelector.superEnd(); |
| } |
| |
| mockSelector = new MockAbstractSelector(SelectorProvider.provider()); |
| try { |
| mockSelector.superBegin(); |
| mockSelector.close(); |
| } finally { |
| mockSelector.superEnd(); |
| } |
| |
| try { |
| // begin twice |
| mockSelector.superBegin(); |
| mockSelector.superBegin(); |
| } finally { |
| mockSelector.superEnd(); |
| } |
| |
| try { |
| mockSelector.superBegin(); |
| } finally { |
| // end twice |
| mockSelector.superEnd(); |
| mockSelector.superEnd(); |
| } |
| |
| mockSelector.close(); |
| try { |
| mockSelector.superBegin(); |
| } finally { |
| mockSelector.superEnd(); |
| } |
| } |
| |
| /** |
| * @tests AbstractSelector#isOpen() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isOpen", |
| args = {} |
| ) |
| public void test_isOpen() throws Exception { |
| Selector acceptSelector = SelectorProvider.provider().openSelector(); |
| assertTrue(acceptSelector.isOpen()); |
| acceptSelector.close(); |
| assertFalse(acceptSelector.isOpen()); |
| } |
| |
| /** |
| * @tests AbstractSelector() |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "AbstractSelector", |
| args = {SelectorProvider.class} |
| ) |
| public void test_Constructor_LSelectorProvider() throws Exception { |
| Selector acceptSelector = new MockAbstractSelector( |
| SelectorProvider.provider()); |
| assertSame(SelectorProvider.provider(), acceptSelector.provider()); |
| } |
| |
| /** |
| * @tests AbstractSelector#register(AbstractSelectableChannel,int,Object) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies register method from SelectableChannel class.", |
| method = "register", |
| args = {AbstractSelectableChannel.class, int.class, java.lang.Object.class} |
| ) |
| public void test_register_LAbstractSelectableChannelIObject() |
| throws Exception { |
| Selector acceptSelector = new MockSelectorProvider().openSelector(); |
| ServerSocketChannel ssc = ServerSocketChannel.open(); |
| ssc.configureBlocking(false); |
| |
| assertFalse(ssc.isRegistered()); |
| ssc.register(acceptSelector, SelectionKey.OP_ACCEPT); |
| assertTrue(ssc.isRegistered()); |
| assertTrue(((MockAbstractSelector)acceptSelector).isRegisterCalled); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "cancelledKeys", |
| args = {} |
| ) |
| public void test_cancelledKeys() throws Exception { |
| MockSelectorProvider prov = new MockSelectorProvider(); |
| Selector acceptSelector = prov.openSelector(); |
| SocketChannel sc = prov.openSocketChannel(); |
| sc.configureBlocking(false); |
| |
| SelectionKey acceptKey = sc.register(acceptSelector, |
| SelectionKey.OP_READ, null); |
| acceptKey.cancel(); |
| Set<SelectionKey> cKeys = |
| ((MockAbstractSelector)acceptSelector).getCancelledKeys(); |
| assertTrue(cKeys.contains(acceptKey)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "deregister", |
| args = {AbstractSelectionKey.class} |
| ) |
| public void test_deregister() throws Exception { |
| MockSelectorProvider prov = new MockSelectorProvider(); |
| AbstractSelector acceptSelector = prov.openSelector(); |
| SocketChannel sc = prov.openSocketChannel(); |
| sc.configureBlocking(false); |
| |
| SelectionKey acceptKey = sc.register(acceptSelector, |
| SelectionKey.OP_READ, null); |
| assertTrue(sc.isRegistered()); |
| assertNotNull(acceptKey); |
| ((MockAbstractSelector)acceptSelector).mockDeregister( |
| (MockAbstractSelector.MockSelectionKey)acceptKey); |
| assertFalse(sc.isRegistered()); |
| } |
| |
| static class MockSelectorProvider extends SelectorProvider { |
| |
| private MockSelectorProvider() { |
| // do nothing |
| } |
| |
| @Override |
| public DatagramChannel openDatagramChannel() { |
| return null; |
| } |
| |
| @Override |
| public Pipe openPipe() { |
| return null; |
| } |
| |
| @Override |
| public AbstractSelector openSelector() { |
| return new MockAbstractSelector(provider()); |
| } |
| |
| @Override |
| public ServerSocketChannel openServerSocketChannel() { |
| return null; |
| } |
| |
| @Override |
| public SocketChannel openSocketChannel() throws IOException { |
| return SocketChannel.open(); |
| } |
| |
| public static SelectorProvider provider() { |
| return new MockSelectorProvider(); |
| } |
| } |
| } |