From d3a1dc3eea01ae586bb3b1e91246b99f386f5c1d Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 28 Jul 2022 11:06:43 +0800 Subject: [PATCH 01/12] update case lib --- build.gradle | 2 +- library/build.gradle | 19 +- .../java/com/qiniu/android/BaseTest.java | 84 +++- .../java/com/qiniu/android/CrcTest.java | 14 - .../qiniu/android/FastDatePrinterTest.java | 7 + .../java/com/qiniu/android/TempFile.java | 4 + .../com/qiniu/android/UploadFileInfoTest.java | 6 + .../java/com/qiniu/android/WaitTest.java | 9 + .../bigdata/BigDataConfigurationTest.java | 32 ++ .../android/bigdata/client/ClientTest.java | 87 ++++ .../bigdata/pipeline/PipelineTest.java | 180 ++++++++ .../collect/UploadInfoReporterTest.java | 122 ++++++ .../android/collect/UploadReportItemTest.java | 109 +++++ .../com/qiniu/android/collect/UplogTest.java | 77 ++++ .../qiniu/android/common/AutoZoneTest.java | 12 + .../android/common/CollectConfigTest.java | 33 ++ .../qiniu/android/http/HttpHeaderTest.java | 119 ++++++ .../java/com/qiniu/android/http/HttpTest.java | 311 ++++++++++++++ .../com/qiniu/android/http/HttpsTest.java | 121 ++++++ .../qiniu/android/http/ResponseInfoTest.java | 41 ++ .../http/connectCheck/ConnectCheckTest.java | 55 +++ .../qiniu/android/http/dns/DnsApiTest.java | 129 ++++++ .../android/http/dns/DnsCacheFileTest.java | 66 +++ .../android/http/dns/DnsTransactionTest.java | 128 ++++++ .../qiniu/android/http/dns/HappyDnsTest.java | 34 ++ .../qiniu/android/http/dns/SystemDnsTest.java | 43 ++ .../http/request/RequestTransactionTest.java | 201 +++++++++ .../httpclient/SystemHttpClientTest.java | 120 ++++++ .../serverRegion/UploadDomainRegionTest.java | 36 ++ .../UploadServerFreezeManagerTest.java | 39 ++ .../serverRegion/HttpServerManagerTest.java | 7 + .../com/qiniu/android/storage/CancelTest.java | 318 ++++++++++++++ .../storage/ComplexUploadSceneTest.java | 139 ++++++ .../storage/ConcurrentResumeUploadTest.java | 342 +++++++++++++++ .../qiniu/android/storage/FormUploadTest.java | 246 +++++++++++ .../android/storage/ResumeUploadTest.java | 401 ++++++++++++++++++ .../com/qiniu/android/storage/RetryTest.java | 211 +++++++++ .../android/storage/SyncFormUploadTest.java | 202 +++++++++ .../android/storage/TestFileRecorder.java | 239 +++++++++++ .../com/qiniu/android/storage/TokenTest.java | 51 +++ .../qiniu/android/storage/UploadBaseTest.java | 277 ++++++++++++ .../qiniu/android/storage/UploadFlowTest.java | 361 ++++++++++++++++ .../com/qiniu/android/storage/UriTest.java | 203 +++++++++ .../serverConfig/ServerConfigTest.java | 73 ++++ .../transaction/TransactionManagerTest.java | 8 + .../android/utils/AndroidNetworkTest.java | 25 ++ .../com/qiniu/android/utils/AsynTest.java | 151 +++++++ .../com/qiniu/android/utils/Base64Test.java | 18 + .../com/qiniu/android/utils/ContextTest.java | 20 + .../java/com/qiniu/android/utils/CrcTest.java | 21 + .../com/qiniu/android/utils/EtagTest.java | 61 +++ .../com/qiniu/android/utils/GZipTest.java | 59 +++ .../com/qiniu/android/utils/JsonTest.java | 121 ++++++ .../qiniu/android/utils/ListVectorTest.java | 84 ++++ .../com/qiniu/android/utils/LogUtilsTest.java | 54 +++ .../com/qiniu/android/utils/NetworkTest.java | 21 + .../qiniu/android/utils/SingleFlightTest.java | 197 +++++++++ .../qiniu/android/utils/StringUtilsTest.java | 60 +++ .../com/qiniu/android/utils/UtilsTest.java | 77 ++++ 59 files changed, 6264 insertions(+), 23 deletions(-) delete mode 100644 library/src/androidTest/java/com/qiniu/android/CrcTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/bigdata/BigDataConfigurationTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/bigdata/client/ClientTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/bigdata/pipeline/PipelineTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/collect/UploadInfoReporterTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/collect/UploadReportItemTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/common/CollectConfigTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/HttpTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/HttpsTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/ResponseInfoTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/connectCheck/ConnectCheckTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/dns/DnsCacheFileTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/dns/HappyDnsTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/dns/SystemDnsTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/request/RequestTransactionTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/request/httpclient/SystemHttpClientTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadDomainRegionTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadServerFreezeManagerTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/CancelTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/ComplexUploadSceneTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/ConcurrentResumeUploadTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/FormUploadTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/ResumeUploadTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/RetryTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/SyncFormUploadTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/TestFileRecorder.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/TokenTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/UriTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/storage/serverConfig/ServerConfigTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/AndroidNetworkTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/AsynTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/Base64Test.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/ContextTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/CrcTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/EtagTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/GZipTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/JsonTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/ListVectorTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/LogUtilsTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/NetworkTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/SingleFlightTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/StringUtilsTest.java create mode 100644 library/src/androidTest/java/com/qiniu/android/utils/UtilsTest.java diff --git a/build.gradle b/build.gradle index 6e6d9a6e9..e8108abd2 100644 --- a/build.gradle +++ b/build.gradle @@ -9,7 +9,7 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.5.2' + classpath 'com.android.tools.build:gradle:3.5.4' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } diff --git a/library/build.gradle b/library/build.gradle index f9c035cc2..9f1bd53b1 100755 --- a/library/build.gradle +++ b/library/build.gradle @@ -29,6 +29,7 @@ android { versionCode code versionName version } + buildTypes { release { minifyEnabled false @@ -37,16 +38,15 @@ android { debug { testCoverageEnabled = true } - } lintOptions { warning 'InvalidPackage' } - useLibrary 'android.test.runner' - useLibrary 'android.test.base' - useLibrary 'android.test.mock' +// useLibrary 'android.test.runner' +// useLibrary 'android.test.base' +// useLibrary 'android.test.mock' } @@ -60,7 +60,16 @@ dependencies { implementation 'org.conscrypt:conscrypt-android:2.2.1' implementation fileTree(include: ['*.jar'], dir: 'libs') - androidTestImplementation 'junit:junit:4.12' + androidTestImplementation 'junit:junit:4.13.2' + androidTestImplementation "androidx.test.ext:junit:1.1.3" + androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' + +// androidTestImplementation "androidx.test:runner:1.4.0" +// androidTestImplementation "androidx.test:core:1.4.0" +// androidTestImplementation "androidx.test:rules:1.4.0" + +// androidTestImplementation 'org.testng:testng:6.9.6' + androidTestCompileOnly project(path: ':library') // androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0' } diff --git a/library/src/androidTest/java/com/qiniu/android/BaseTest.java b/library/src/androidTest/java/com/qiniu/android/BaseTest.java index 18c9f6c32..8ca1a1a41 100644 --- a/library/src/androidTest/java/com/qiniu/android/BaseTest.java +++ b/library/src/androidTest/java/com/qiniu/android/BaseTest.java @@ -1,8 +1,18 @@ package com.qiniu.android; -import com.qiniu.android.utils.LogUtil; +import android.content.Context; -import android.test.AndroidTestCase; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.platform.app.InstrumentationRegistry; + +import com.qiniu.android.transaction.TransactionManager; + +import junit.framework.TestCase; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.runner.RunWith; import java.util.Date; import java.util.concurrent.CountDownLatch; @@ -11,10 +21,18 @@ /** * Created by yangsen on 2020/5/26 */ -public class BaseTest extends AndroidTestCase{ +//@RunWith(AndroidJUnit4.class) +public class BaseTest { private long maxWaitTimestamp = 0; + private Context context; + + @Before + public void setUp() throws Exception { + context = ApplicationProvider.getApplicationContext(); + } + /** * waitCondition: 等待条件 * maxWaitTime: 等待最大时长 单位-秒 @@ -41,6 +59,9 @@ public void wait(WaitConditional waitConditional, float maxWaitTime) { } } + protected Context getContext() { + return context; + } public interface WaitConditional { boolean shouldWait(); @@ -71,4 +92,61 @@ private void notestWait() { assertTrue(((startTimestamp + waitTime * 1000) < endTimestamp)); } + + + protected void fail(String message) { + Assert.fail(message); + } + + protected void assertTrue(boolean condition) { + Assert.assertTrue(condition); + } + + protected void assertTrue(String message, boolean condition) { + Assert.assertTrue(message, condition); + } + + protected void assertFalse(boolean condition) { + Assert.assertFalse(condition); + } + + protected void assertFalse(String message, boolean condition) { + Assert.assertFalse(message, condition); + } + + protected void assertNull(Object object) { + Assert.assertNull(object); + } + + protected void assertNull(String message, Object object) { + Assert.assertNull(message, object); + } + + protected void assertNotNull(Object object) { + Assert.assertNotNull(object); + } + + protected void assertNotNull(String message, Object object) { + Assert.assertNotNull(message, object); + } + + protected void assertEquals(Object expected, Object actual) { + Assert.assertEquals(expected, actual); + } + + protected void assertEquals(String message, Object expected, Object actual) { + Assert.assertEquals(message, expected, actual); + } + + protected void assertEquals(String message, long expected, long actual) { + Assert.assertEquals(message, expected, actual); + } + + protected void assertEquals(int expected, int actual) { + Assert.assertEquals(expected, actual); + } + + protected void assertEquals(String message, int expected, int actual) { + Assert.assertEquals(message, expected, actual); + } } diff --git a/library/src/androidTest/java/com/qiniu/android/CrcTest.java b/library/src/androidTest/java/com/qiniu/android/CrcTest.java deleted file mode 100644 index 639c45c93..000000000 --- a/library/src/androidTest/java/com/qiniu/android/CrcTest.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; -import com.qiniu.android.utils.Crc32; -import junit.framework.Assert; - - -public class CrcTest extends AndroidTestCase { - public void testCrc() { - byte[] data = "Hello, World!".getBytes(); - long result = Crc32.bytes(data); - Assert.assertEquals(3964322768L, result); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/FastDatePrinterTest.java b/library/src/androidTest/java/com/qiniu/android/FastDatePrinterTest.java index 1a6d20d7c..d9f8fdd93 100644 --- a/library/src/androidTest/java/com/qiniu/android/FastDatePrinterTest.java +++ b/library/src/androidTest/java/com/qiniu/android/FastDatePrinterTest.java @@ -1,14 +1,21 @@ package com.qiniu.android; +import androidx.test.ext.junit.runners.AndroidJUnit4; + import com.qiniu.android.utils.FastDatePrinter; import com.qiniu.android.utils.LogUtil; +import org.junit.Test; +import org.junit.runner.RunWith; + import java.util.Date; import java.util.Locale; import java.util.TimeZone; +@RunWith(AndroidJUnit4.class) public class FastDatePrinterTest extends BaseTest { + @Test public void testCreate(){ Date date = new Date(1595474306393l); diff --git a/library/src/androidTest/java/com/qiniu/android/TempFile.java b/library/src/androidTest/java/com/qiniu/android/TempFile.java index 03bf95a79..2501fb257 100644 --- a/library/src/androidTest/java/com/qiniu/android/TempFile.java +++ b/library/src/androidTest/java/com/qiniu/android/TempFile.java @@ -1,5 +1,9 @@ package com.qiniu.android; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.runner.RunWith; + import java.io.File; import java.io.FileOutputStream; import java.io.IOException; diff --git a/library/src/androidTest/java/com/qiniu/android/UploadFileInfoTest.java b/library/src/androidTest/java/com/qiniu/android/UploadFileInfoTest.java index d4f995a11..0cc72139a 100644 --- a/library/src/androidTest/java/com/qiniu/android/UploadFileInfoTest.java +++ b/library/src/androidTest/java/com/qiniu/android/UploadFileInfoTest.java @@ -1,8 +1,14 @@ package com.qiniu.android; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) public class UploadFileInfoTest extends BaseTest { + @Test public void testCreateFromJsonError(){ diff --git a/library/src/androidTest/java/com/qiniu/android/WaitTest.java b/library/src/androidTest/java/com/qiniu/android/WaitTest.java index 911720c30..8c482326e 100644 --- a/library/src/androidTest/java/com/qiniu/android/WaitTest.java +++ b/library/src/androidTest/java/com/qiniu/android/WaitTest.java @@ -1,11 +1,20 @@ package com.qiniu.android; +import static org.junit.Assert.assertEquals; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + import com.qiniu.android.utils.Wait; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) public class WaitTest extends BaseTest { public int count = 0; + @Test public void testWait() { final Wait wait = new Wait(); diff --git a/library/src/androidTest/java/com/qiniu/android/bigdata/BigDataConfigurationTest.java b/library/src/androidTest/java/com/qiniu/android/bigdata/BigDataConfigurationTest.java new file mode 100644 index 000000000..f643447a5 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/bigdata/BigDataConfigurationTest.java @@ -0,0 +1,32 @@ +package com.qiniu.android.bigdata; + + +import static org.junit.Assert.assertTrue; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class BigDataConfigurationTest { + + @Test + public void testCopy() { + Configuration configuration = new Configuration(); + configuration.connectTimeout = 15; + + Configuration configurationCopy = Configuration.copy(configuration); + + assertTrue(configurationCopy.connectTimeout == configuration.connectTimeout); + } + + @Test + public void testCopyNoValue() { + Configuration configuration = null; + + Configuration configurationCopy = Configuration.copy(configuration); + + assertTrue(configurationCopy != null); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/bigdata/client/ClientTest.java b/library/src/androidTest/java/com/qiniu/android/bigdata/client/ClientTest.java new file mode 100644 index 000000000..cb921457a --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/bigdata/client/ClientTest.java @@ -0,0 +1,87 @@ +package com.qiniu.android.bigdata.client; + + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TestConfig; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.storage.UpToken; +import com.qiniu.android.utils.StringMap; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class ClientTest extends BaseTest { + + @Test + public void testSyncGet() { + + Client client = new Client(null, 90, 90, null, null); + ResponseInfo responseInfo = client.syncGet("https://up.qiniup.com/crossdomain.xml", null); + assertTrue(responseInfo != null); + assertTrue(responseInfo.statusCode == 200); + } + + @Test + public void testAsyncGet() { + + final WaitCondition waitCondition = new WaitCondition(); + Client client = new Client(); + client.asyncGet("https://up.qiniup.com/crossdomain.xml", null, null, new CompletionHandler() { + @Override + public void complete(ResponseInfo info, JSONObject response) { + + assertTrue(info != null); + assertTrue(info.statusCode == 200); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 10 * 60); + } + + @Test + public void testMultipartSyncPost() { + + PostArgs postArgs = new PostArgs(); + postArgs.data = "123".getBytes(); + postArgs.mimeType = "text/plain"; + postArgs.params = new StringMap(); + postArgs.params.put("x:foo", "foo"); + + UpToken token = UpToken.parse(TestConfig.commonToken); + + Client client = new Client(null, 90, 90, null, null); + ResponseInfo responseInfo = client.syncMultipartPost("http://up.qiniu.com", postArgs, token); + + assertTrue(responseInfo != null); + } + + @Test + public void testMultipartAsyncPost() { + + final WaitCondition waitCondition = new WaitCondition(); + + PostArgs postArgs = new PostArgs(); + postArgs.data = "123".getBytes(); + postArgs.mimeType = "text/plain"; + postArgs.params = new StringMap(); + + UpToken token = UpToken.parse(TestConfig.commonToken); + + Client client = new Client(null, 90, 90, null, null); + client.asyncMultipartPost("http://up.qiniu.com", postArgs, token, null, new CompletionHandler() { + @Override + public void complete(ResponseInfo info, JSONObject response) { + + assertTrue(info != null); + waitCondition.shouldWait = false; + } + }, null); + + wait(waitCondition, 10 * 60); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/bigdata/pipeline/PipelineTest.java b/library/src/androidTest/java/com/qiniu/android/bigdata/pipeline/PipelineTest.java new file mode 100644 index 000000000..4748aa47d --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/bigdata/pipeline/PipelineTest.java @@ -0,0 +1,180 @@ +package com.qiniu.android.bigdata.pipeline; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.http.ResponseInfo; + +import junit.framework.Assert; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +/** + * Created by long on 2017/7/25. + */ + +@RunWith(AndroidJUnit4.class) +public class PipelineTest { + final CountDownLatch signal = new CountDownLatch(1); + private volatile ResponseInfo info = null; + + @Test + public void testPoint() { + StringBuilder b1 = new StringBuilder(); + Points.formatPoint(new A(3), b1); + StringBuilder b2 = new StringBuilder(); + Map m = new HashMap<>(); + m.put("a", 3); + Points.formatPoint(m, b2); + Assert.assertEquals(b1.toString(), b2.toString()); + } + + @Test + public void testPump() { + Map map = new HashMap<>(); + map.put("platform", "android"); + map.put("tl", 1L); + map.put("tf", 1.0); + map.put("tb", true); + map.put("td", new Date()); + Pipeline pipe = new Pipeline(null); + pipe.pump("testsdk", map, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { + @Override + public void complete(ResponseInfo inf) { + info = inf; + signal.countDown(); + } + }); + + try { + signal.await(1200, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", info); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println(info); +// Assert.assertTrue(info.isOK()); + } + + @Test + public void testPump2() { + Pipeline pipe = new Pipeline(null); + pipe.pump("testsdk", new tsdk(), "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { + @Override + public void complete(ResponseInfo inf) { + info = inf; + signal.countDown(); + } + }); + + try { + signal.await(1200, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", info); + } catch (InterruptedException e) { + e.printStackTrace(); + } +// Assert.assertTrue(info.isOK()); + } + + @Test + public void testPump3() { + Map map = new HashMap<>(); + map.put("platform", "android"); + map.put("tl", 1L); + map.put("tf", 1.0); + map.put("tb", true); + map.put("td", new Date()); + Pipeline pipe = new Pipeline(null); + List> list = new ArrayList<>(); + list.add(map); + list.add(map); + pipe.pumpMulti("testsdk", list, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { + @Override + public void complete(ResponseInfo inf) { + info = inf; + signal.countDown(); + } + }); + + try { + signal.await(1200, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", info); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println(info); +// Assert.assertTrue(info.isOK()); + } + + @Test + public void testPump4() { + Pipeline pipe = new Pipeline(null); + List list = new ArrayList<>(); + list.add(new tsdk()); + list.add(new tsdk()); + pipe.pumpMultiObjects("testsdk", list, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { + @Override + public void complete(ResponseInfo inf) { + info = inf; + signal.countDown(); + } + }); + + try { + signal.await(1200, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", info); + } catch (InterruptedException e) { + e.printStackTrace(); + } +// Assert.assertTrue(info.isOK()); + } + + @Test + public void testPump5() { + Pipeline pipe = new Pipeline(null); + tsdk[] t = new tsdk[2]; + t[0] = new tsdk(); + t[1] = new tsdk(); + pipe.pumpMultiObjects("testsdk", t, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { + @Override + public void complete(ResponseInfo inf) { + info = inf; + signal.countDown(); + } + }); + + try { + signal.await(1200, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", info); + } catch (InterruptedException e) { + e.printStackTrace(); + } +// Assert.assertTrue(info.isOK()); + } + + static class A { + public Integer a; + + A(int i) { + a = i; + } + } + + static class tsdk { + public String platform = "android2"; + public long tl = 2; + public double tf = 2.0; + public boolean tb = true; + public Date td = new Date(); + + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/collect/UploadInfoReporterTest.java b/library/src/androidTest/java/com/qiniu/android/collect/UploadInfoReporterTest.java new file mode 100644 index 000000000..45d0da6e2 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/collect/UploadInfoReporterTest.java @@ -0,0 +1,122 @@ +package com.qiniu.android.collect; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.BaseTest; +import com.qiniu.android.utils.LogUtil; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.Date; +import java.util.concurrent.CountDownLatch; + +/** + * Created by yangsen on 2020/5/25 + */ +@RunWith(AndroidJUnit4.class) +public class UploadInfoReporterTest extends BaseTest { + + private CountDownLatch signal = null; + + private class TestParam{ + int totalCount = 50; + int completeCount = 0; + } + + @Test + public void testNoReporter(){ + ReportConfig.getInstance().isReportEnable = false; + + report(null); + ReportItem item = new ReportItem(); + item.setReport(ReportItem.LogTypeQuality, ReportItem.QualityKeyLogType); + item.setReport((new Date().getTime() / 1000), ReportItem.QualityKeyUpTime); + item.setReport("ok", ReportItem.QualityKeyResult); + item.setReport(1, ReportItem.QualityKeyTotalElapsedTime); + item.setReport(1, ReportItem.QualityKeyRequestsCount); + item.setReport(1, ReportItem.QualityKeyRegionsCount); + item.setReport(1, ReportItem.QualityKeyBytesSent); + report(item); + + wait(null, 1); + + ReportConfig.getInstance().isReportEnable = true; + } + + @Test + public void testSave(){ + + UploadInfoReporter.getInstance().clean(); + signal = new CountDownLatch(1); + final String time = new Date().toString(); + for (int i = 0; i < 50; i++) { + final int iP = i; + new Thread(new Runnable() { + @Override + public void run() { + ReportItem item = new ReportItem(); + item.setReport(ReportItem.LogTypeQuality, ReportItem.QualityKeyLogType); + item.setReport((new Date().getTime() / 1000), ReportItem.QualityKeyUpTime); + item.setReport("ok", ReportItem.QualityKeyResult); + item.setReport(1, ReportItem.QualityKeyTotalElapsedTime); + item.setReport(1, ReportItem.QualityKeyRequestsCount); + item.setReport(1, ReportItem.QualityKeyRegionsCount); + item.setReport(1, ReportItem.QualityKeyBytesSent); + report(item); + } + }).start(); + } + + wait(null, 5); + + File logFile = new File(ReportConfig.getInstance().recordDirectory + "/qiniu.log"); + showContent(logFile); + + File logTempFile = new File(ReportConfig.getInstance().recordDirectory + "/qiniuTemp.log"); + showContent(logTempFile); + + } + + private void report(ReportItem item){ + UploadInfoReporter reporter = UploadInfoReporter.getInstance(); + reporter.report(item, TestConfig.token_z0); + } + + private static void showContent(File recordFile) { + FileReader fileReader = null; + BufferedReader br = null; + try { + fileReader = new FileReader(recordFile); + br = new BufferedReader(fileReader); + String line = null; + LogUtil.d("== " + recordFile.getPath() + ": start"); + while ((line = br.readLine()) != null) { + LogUtil.d(("== " + line)); + } + LogUtil.d("== " + recordFile.getPath() + ": end"); + } catch (Exception e) { + + } finally { + if (br != null) { + try { + br.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + if (fileReader != null) { + try { + fileReader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/collect/UploadReportItemTest.java b/library/src/androidTest/java/com/qiniu/android/collect/UploadReportItemTest.java new file mode 100644 index 000000000..b5d03a8bb --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/collect/UploadReportItemTest.java @@ -0,0 +1,109 @@ +package com.qiniu.android.collect; + + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.http.request.Request; +import com.qiniu.android.BaseTest; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.HashMap; + +@RunWith(AndroidJUnit4.class) +public class UploadReportItemTest extends BaseTest { + + @Test + public void testSetAndRemoveValue(){ + + ReportItem reportItem = new ReportItem(); + reportItem.setReport(ReportItem.LogTypeRequest, ReportItem.RequestKeyLogType); + + String json = reportItem.toJson(); + assertTrue(! json.equals("{}")); + + reportItem.removeReportValue(ReportItem.RequestKeyLogType); + + json = reportItem.toJson(); + assertTrue(json.equals("{}")); + } + + @Test + public void testReportStatusCode(){ + ResponseInfo responseInfo = createResponseInfo(ResponseInfo.Cancelled); + assertTrue(ReportItem.requestReportStatusCode(responseInfo) != null); + + responseInfo = createResponseInfo(200); + assertTrue(ReportItem.requestReportStatusCode(responseInfo).equals("200")); + } + + @Test + public void testReportErrorType(){ + ResponseInfo responseInfo = createResponseInfo(200); + assertTrue(ReportItem.qualityResult(responseInfo).equals("ok")); + + responseInfo = createResponseInfo(400); + assertTrue(ReportItem.qualityResult(responseInfo).equals("bad_request")); + + responseInfo = createResponseInfo(ResponseInfo.ZeroSizeFile); + assertTrue(ReportItem.qualityResult(responseInfo).equals("zero_size_file")); + + responseInfo = createResponseInfo(ResponseInfo.InvalidFile); + assertTrue(ReportItem.qualityResult(responseInfo).equals("invalid_file")); + + responseInfo = createResponseInfo(ResponseInfo.InvalidToken); + assertTrue(ReportItem.qualityResult(responseInfo).equals("invalid_args")); + + responseInfo = createResponseInfo(ResponseInfo.NetworkError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("network_error")); + + responseInfo = createResponseInfo(ResponseInfo.TimedOut); + assertTrue(ReportItem.qualityResult(responseInfo).equals("timeout")); + + responseInfo = createResponseInfo(ResponseInfo.CannotConnectToHost); + assertTrue(ReportItem.qualityResult(responseInfo).equals("cannot_connect_to_host")); + + responseInfo = createResponseInfo(ResponseInfo.NetworkConnectionLost); + assertTrue(ReportItem.qualityResult(responseInfo).equals("transmission_error")); + + responseInfo = createResponseInfo(ResponseInfo.NetworkSSLError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("ssl_error")); + + responseInfo = createResponseInfo(ResponseInfo.ParseError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("parse_error")); + + responseInfo = createResponseInfo(ResponseInfo.MaliciousResponseError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("malicious_response")); + + responseInfo = createResponseInfo(ResponseInfo.Cancelled); + assertTrue(ReportItem.qualityResult(responseInfo).equals("user_canceled")); + + responseInfo = createResponseInfo(ResponseInfo.LocalIOError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("local_io_error")); + + responseInfo = createResponseInfo(ResponseInfo.NetworkProtocolError); + assertTrue(ReportItem.qualityResult(responseInfo).equals("protocol_error")); + + responseInfo = createResponseInfo(ResponseInfo.NetworkSlow); + assertTrue(ReportItem.qualityResult(responseInfo).equals("network_slow")); + + responseInfo = createResponseInfo(614); + assertTrue(ReportItem.qualityResult(responseInfo).equals("bad_request")); + } + + + private ResponseInfo createResponseInfo(int statusCode){ + + HashMaprequestHeader = new HashMap<>(); + + Request request = new Request("url", "GET", requestHeader, null, 10); + + HashMapresponseHeader = new HashMap<>(); + responseHeader.put("x-reqid", "req-id"); + responseHeader.put("x-log", "log"); + return ResponseInfo.create(request, statusCode, responseHeader, new JSONObject(), ""); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java b/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java new file mode 100644 index 000000000..b167826cc --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java @@ -0,0 +1,77 @@ +package com.qiniu.android.collect; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.BaseTest; + +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class UplogTest extends BaseTest { + + private void no_testUplog() { + ReportItem item = new ReportItem(); + item.setReport(ReportItem.LogTypeRequest, ReportItem.RequestKeyLogType); + item.setReport(1634567890, ReportItem.RequestKeyUpTime); + item.setReport(200, ReportItem.RequestKeyStatusCode); + item.setReport("reqid", ReportItem.RequestKeyRequestId); + item.setReport("host", ReportItem.RequestKeyHost); + item.setReport("remoteAddress", ReportItem.RequestKeyRemoteIp); + item.setReport(80, ReportItem.RequestKeyPort); + item.setReport("bucket", ReportItem.RequestKeyTargetBucket); + item.setReport("key", ReportItem.RequestKeyTargetKey); + item.setReport(123, ReportItem.RequestKeyTotalElapsedTime); + item.setReport(123, ReportItem.RequestKeyDnsElapsedTime); + item.setReport(123, ReportItem.RequestKeyConnectElapsedTime); + item.setReport(123, ReportItem.RequestKeyTLSConnectElapsedTime); + item.setReport(123, ReportItem.RequestKeyRequestElapsedTime); + item.setReport(123, ReportItem.RequestKeyWaitElapsedTime); + item.setReport(123, ReportItem.RequestKeyResponseElapsedTime); + item.setReport(123, ReportItem.RequestKeyFileOffset); + item.setReport(123, ReportItem.RequestKeyBytesSent); + item.setReport(123, ReportItem.RequestKeyBytesTotal); + item.setReport("123", ReportItem.RequestKeyPid); + item.setReport(123, ReportItem.RequestKeyTid); + item.setReport("regionid", ReportItem.RequestKeyTargetRegionId); + item.setReport("regionid", ReportItem.RequestKeyCurrentRegionId); + item.setReport("errorType", ReportItem.RequestKeyErrorType); + + item.setReport("errorDesc", ReportItem.RequestKeyErrorDescription); + item.setReport("form", ReportItem.RequestKeyUpType); + item.setReport("android", ReportItem.RequestKeyOsName); + item.setReport("10", ReportItem.RequestKeyOsVersion); + item.setReport("Android", ReportItem.RequestKeySDKName); + item.setReport("8.3.3", ReportItem.RequestKeySDKVersion); + item.setReport(1623456789, ReportItem.RequestKeyClientTime); + item.setReport("wifi", ReportItem.RequestKeyNetworkType); + item.setReport(-1, ReportItem.RequestKeySignalStrength); + + item.setReport("server", ReportItem.RequestKeyPrefetchedDnsSource); + item.setReport(10, ReportItem.RequestKeyPrefetchedBefore); + item.setReport("lastPrefetchErrorMessage", ReportItem.RequestKeyPrefetchedErrorMessage); + + item.setReport("okhttp", ReportItem.RequestKeyHttpClient); + item.setReport("4.2.2", ReportItem.RequestKeyHttpClientVersion); + item.setReport("disable", ReportItem.RequestKeyNetworkMeasuring); + + // 劫持标记 + item.setReport("hijacked", ReportItem.RequestKeyHijacking); + item.setReport("syncDnsSource", ReportItem.RequestKeyDnsSource); + item.setReport("syncDnsError", ReportItem.RequestKeyDnsErrorMessage); + + // 统计当前请求上传速度 / 总耗时 + item.setReport(123, ReportItem.RequestKeyPerceptiveSpeed); + + item.setReport("http1.1", ReportItem.RequestKeyHttpVersion); + + UploadInfoReporter.getInstance().report(item, TestConfig.commonToken); + +// wait(new WaitConditional() { +// @Override +// public boolean shouldWait() { +// return true; +// } +// }, 10 * 60); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/common/AutoZoneTest.java b/library/src/androidTest/java/com/qiniu/android/common/AutoZoneTest.java index ef406d07b..2b2ff559f 100644 --- a/library/src/androidTest/java/com/qiniu/android/common/AutoZoneTest.java +++ b/library/src/androidTest/java/com/qiniu/android/common/AutoZoneTest.java @@ -1,5 +1,7 @@ package com.qiniu.android.common; +import androidx.test.ext.junit.runners.AndroidJUnit4; + import com.qiniu.android.BaseTest; import com.qiniu.android.TestConfig; import com.qiniu.android.http.ResponseInfo; @@ -7,16 +9,21 @@ import com.qiniu.android.storage.UpToken; import com.qiniu.android.utils.LogUtil; +import org.junit.Test; +import org.junit.runner.RunWith; + import java.util.concurrent.atomic.AtomicInteger; /** * Created by long on 2016/9/30. */ +@RunWith(AndroidJUnit4.class) public class AutoZoneTest extends BaseTest { private String ak = TestConfig.ak; private String bkt = "javasdk"; + @Test public void testClearAutoZoneCache() { final WaitCondition waitCondition = new WaitCondition(); AutoZone zone = new AutoZone(); @@ -42,6 +49,7 @@ public void complete(int code, ResponseInfo responseInfo, UploadRegionRequestMet assertTrue("after clear cache: info was't temporary", info.isTemporary()); } + @Test public void testHttp() { final WaitCondition waitCondition = new WaitCondition(); @@ -96,6 +104,7 @@ public void complete(boolean isSuccess) { // } private boolean isTestUCServerComplete = false; + @Test public void testUCServer(){ String ucServer = "uc.server.test"; AutoZone autoZone = new AutoZone(); @@ -122,6 +131,7 @@ public boolean shouldWait() { assertTrue(autoZone.getZonesInfo(null) == null); } + @Test public void testMufiHttp() { final TestParam param = new TestParam(); @@ -178,6 +188,7 @@ public void complete(int code, ResponseInfo responseInfo, UploadRegionRequestMet }); } + @Test public void testAutoZone() { final AutoZone zone = new AutoZone(); final UpToken token = UpToken.parse(TestConfig.commonToken); @@ -212,6 +223,7 @@ public boolean shouldWait() { assertTrue("preQueryHost02 test complete:" + param.success, param.success); } + @Test public void testSetUcHosts02() { final AutoZone zone = new AutoZone(); zone.setUcServers(new String[]{Config.preQueryHost02}); diff --git a/library/src/androidTest/java/com/qiniu/android/common/CollectConfigTest.java b/library/src/androidTest/java/com/qiniu/android/common/CollectConfigTest.java new file mode 100644 index 000000000..fe9bfcd59 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/common/CollectConfigTest.java @@ -0,0 +1,33 @@ +package com.qiniu.android.common; + +import static org.junit.Assert.assertTrue; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class CollectConfigTest { + + @Test + public void testQuick(){ + Config.quick(); + assertTrue(Config.uploadThreshold == 1024); + assertTrue(Config.interval == 2); + } + + @Test + public void testNormal(){ + Config.normal(); + assertTrue(Config.uploadThreshold == 4*1024); + assertTrue(Config.interval == 10); + } + + @Test + public void testSlow(){ + Config.slow(); + assertTrue(Config.uploadThreshold == 150*1024); + assertTrue(Config.interval == 300); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java b/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java new file mode 100644 index 000000000..d873857e9 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java @@ -0,0 +1,119 @@ +package com.qiniu.android.http; + +import static org.junit.Assert.assertTrue; + +import com.qiniu.android.utils.LogUtil; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Date; +import java.util.HashMap; + +@RunWith(AndroidJUnit4.class) +public class HttpHeaderTest { + + private Headers headers; + + @Before + protected void setUp() throws Exception { + + HashMap keyVaules = new HashMap<>(); + keyVaules.put("date", "2020-07-15 07:40:01"); + keyVaules.put("host", "127.0.0.1"); + headers = Headers.of(keyVaules); + LogUtil.i(headers.names().toString()); + } + + @Test + public void testValue() { + + assertTrue(headers.values("date") != null); + assertTrue(headers.values("host") != null); + } + + @Test + public void testCount() { + + assertTrue(headers.byteCount() > 0); + } + + @Test + public void testBuilder() { + String dateKey = "date"; + String dateValue = HttpDate.format(new Date()); + String hostKey = "host"; + String hostValue = "127.0.0.1"; + + Headers.Builder builder0 = new Headers.Builder(); + builder0.add(dateKey, dateValue); + builder0.add(hostKey + ":" + hostValue); + Headers headers0 = builder0.build(); + + assertTrue(headers0.get(dateKey).equals(dateValue)); + assertTrue(headers0.getDate(dateKey) != null); + assertTrue(headers0.get(hostKey).equals(hostValue)); + + + Headers.Builder builder1 = new Headers.Builder(); + builder1.addAll(headers0); + assertTrue(builder1.get(dateKey).equals(dateValue)); + + + Headers headers1 = headers0.newBuilder().build(); + assertTrue(headers1.equals(headers0)); + assertTrue(headers1.toString().equals(headers0.toString())); + assertTrue(headers1.hashCode() == headers0.hashCode()); + + + Headers headers = Headers.of(hostKey, hostValue, dateKey, dateValue); + assertTrue(headers.get(dateKey).equals(dateValue)); + + + headers1.toMultimap(); + + + builder1.set("time", "2020-07-10 10:20:14"); + headers1 = builder1.build(); + assertTrue(headers1.get("time").equals("2020-07-10 10:20:14")); + + builder1.removeAll("time"); + headers1 = builder1.build(); + assertTrue(headers1.get("time") == null); + } + + @Test + public void testBuilderError() { + + Headers headers = null; + + String headersString = null; + try { + headers = Headers.of(headersString); + } catch (Exception e) { + assertTrue(true); + } + + try { + headers = Headers.of("key"); + } catch (Exception e) { + assertTrue(true); + } + + try { + headers = Headers.of("key", null); + } catch (Exception e) { + assertTrue(true); + } + + try { + headers = Headers.of("key", ""); + } catch (Exception e) { + assertTrue(true); + } + + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/HttpTest.java b/library/src/androidTest/java/com/qiniu/android/http/HttpTest.java new file mode 100644 index 000000000..064494422 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/HttpTest.java @@ -0,0 +1,311 @@ +package com.qiniu.android.http; + + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.bigdata.client.Client; +import com.qiniu.android.bigdata.client.CompletionHandler; +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.UpToken; +import com.qiniu.android.utils.AsyncRun; +import com.qiniu.android.utils.LogUtil; +import com.qiniu.android.utils.StringMap; + +import junit.framework.Assert; + +import org.json.JSONObject; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.Charset; + + +/** + * Created by bailong on 14/10/12. + */ +@RunWith(AndroidJUnit4.class) +public class HttpTest extends BaseTest { + private Client httpManager; + private ResponseInfo info; + + private static URI newURI(String s) { + try { + return new URI(s); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + return null; + } + + @Override + @Before + public void setUp() throws Exception { + httpManager = new Client(null, 90, 90, null, null); + } + + @Test + public void testPost1() throws Throwable { + + httpManager.asyncPost("http://www.baidu.com", + "hello".getBytes(), null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + Assert.assertNotNull(rinfo); + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + Assert.assertTrue(info.reqId == ""); + } + + @Test + public void testPost2() throws Throwable { + + httpManager.asyncPost("http://up.qiniu.com", "hello".getBytes(), null, + UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + Assert.assertNotNull(info.reqId); + } + + @Test + public void testPost3() throws Throwable { + AsyncRun.runInMain(new Runnable() { // THIS IS THE KEY TO SUCCESS + public void run() { + + httpManager.asyncPost("http://httpbin.org/status/500", "hello".getBytes(), + null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + } + }); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + Assert.assertEquals(500, info.statusCode); + Assert.assertNotNull(info.error); + } + + @Test + public void testPost4() throws Throwable { + AsyncRun.runInMain(new Runnable() { // THIS IS THE KEY TO SUCCESS + public void run() { + httpManager.asyncPost("http://httpbin.org/status/418", + "hello".getBytes(), + null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + } + }); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 5); + + Assert.assertEquals(418, info.statusCode); + Assert.assertNotNull(info.error); + } + + @Test + public void testPostNoDomain() throws Throwable { + + + httpManager.asyncPost("http://no-domain.qiniu.com", "hello".getBytes(), + null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + Assert.assertEquals("", info.reqId); + Assert.assertEquals(ResponseInfo.UnknownHost, info.statusCode); + } + +// @SmallTest +// public void testPostNoPort() throws Throwable { +// +// httpManager.asyncPost("http://up.qiniu.com:12345", "hello".getBytes(), +// null, null, new CompletionHandler() { +// @Override +// public void complete(ResponseInfo rinfo, JSONObject response) { +// LogUtil.d(rinfo.toString()); +// info = rinfo; +// signal.countDown(); +// } +// }, null); +// +// try { +// signal.await(60, TimeUnit.SECONDS); // wait for callback +// } catch (InterruptedException e) { +// e.printStackTrace(); +// } +// Assert.assertEquals("", info.reqId); +// Assert.assertTrue(ResponseInfo.CannotConnectToHost == info.statusCode || +// ResponseInfo.TimedOut == info.statusCode); +// } + + @Test + public void testPostIP() throws Throwable { + info = null; + StringMap x = new StringMap().put("Host", "up.qiniu.com"); + + httpManager.asyncPost("http://124.160.115.112", "hello".getBytes(), + x, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + Assert.assertTrue(!"".equals(info.reqId)); + Assert.assertEquals(400, info.statusCode); + } + + @Test + public void testProxy() throws Throwable { + StringMap x = new StringMap(); + ProxyConfiguration p = new ProxyConfiguration("115.238.101.32", 80); + Client c = new Client(p, 10, 30, null, null); + + c.asyncPost("http://upproxy1.qiniu.com", "hello".getBytes(), + x, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, + null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + Assert.assertTrue(!"".equals(info.reqId)); + Assert.assertEquals(400, info.statusCode); + } + + @Test + public void testHeader() { + // com.qiniu.android.http.UserAgent#getUa + // return new String((ua + "; " + _part + ")").getBytes(Charset.forName("ISO-8859-1"))); + + String name = new String(("电话☎️的の").getBytes(Charset.forName("ISO-8859-1"))); + String value = new String(("sdf✈️he覆盖😁🆚9837-=/ df").getBytes(Charset.forName("ISO-8859-1"))); + checkNameAndValue(name, value); + } + + // copy from okhttp3.Headers + private void checkNameAndValue(String name, String value) { + if (name == null) throw new IllegalArgumentException("name == null"); + if (name.isEmpty()) throw new IllegalArgumentException("name is empty"); + for (int i = 0, length = name.length(); i < length; i++) { + char c = name.charAt(i); + if (c <= '\u001f' || c >= '\u007f') { + throw new IllegalArgumentException(String.format( + "Unexpected char %#04x at %d in header name: %s", (int) c, i, name)); + } + } + if (value == null) throw new IllegalArgumentException("value == null"); + for (int i = 0, length = value.length(); i < length; i++) { + char c = value.charAt(i); + if (c <= '\u001f' || c >= '\u007f') { + throw new IllegalArgumentException(String.format( + "Unexpected char %#04x at %d in %s value: %s", (int) c, i, name, value)); + } + } + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/HttpsTest.java b/library/src/androidTest/java/com/qiniu/android/http/HttpsTest.java new file mode 100644 index 000000000..953976a89 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/HttpsTest.java @@ -0,0 +1,121 @@ +package com.qiniu.android.http; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.bigdata.client.Client; +import com.qiniu.android.bigdata.client.CompletionHandler; +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.UpToken; +import com.qiniu.android.utils.LogUtil; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.concurrent.CountDownLatch; + +/** + * Created by bailong on 15/12/1. + */ +@RunWith(AndroidJUnit4.class) +public class HttpsTest extends BaseTest { + final CountDownLatch signal = new CountDownLatch(1); + private Client httpManager; + private ResponseInfo info; + + private static URI newURI(String s) { + try { + return new URI(s); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + return null; + } + + @Override + public void setUp() throws Exception { + httpManager = new Client(); + } + + @Test + public void testPost1() throws Throwable { + + info = null; + httpManager.asyncPost("https://www.baidu.com/", "hello".getBytes(), null, + UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, null, new CompletionHandler() { + @Override + public void complete(ResponseInfo rinfo, JSONObject response) { + LogUtil.d(rinfo.toString()); + info = rinfo; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 5); + + + assertEquals(info.error, 200, info.statusCode); + } + +// @SmallTest +// public void testPost2() throws Throwable { +// +// info = null; +// +// httpManager.asyncPost("https://static-fw.qbox.me/public/v28812/add-on/ga/analytics.js", +// "hello".getBytes(), null, UpToken.parse(TestConfig.token_z0), "hello".getBytes().length, +// null, new CompletionHandler() { +// @Override +// public void complete(ResponseInfo rinfo, JSONObject response) { +// LogUtil.d(rinfo.toString()); +// info = rinfo; +// } +// }, null); +// +// wait(new WaitConditional() { +// @Override +// public boolean shouldWait() { +// if (info == null) { +// return true; +// } else { +// return false; +// } +// } +// }, 5); +// +// assertEquals(info.error, 200, info.statusCode); +// assertNotNull(info.reqId); +// } + +// @SmallTest +// public void testPost3() throws Throwable { +// httpManager.asyncPost("https://up.qiniu.com", +// "hello".getBytes(), null, null, new CompletionHandler() { +// @Override +// public void complete(ResponseInfo rinfo, JSONObject response) { +// LogUtil.d(rinfo.toString()); +// info = rinfo; +// signal.countDown(); +// } +// }, null); +// +// try { +// signal.await(60000, TimeUnit.SECONDS); // wait for callback +// } catch (InterruptedException e) { +// e.printStackTrace(); +// } +// // cert is not match +// Assert.assertEquals(info.error, -1, info.statusCode); +// } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/ResponseInfoTest.java b/library/src/androidTest/java/com/qiniu/android/http/ResponseInfoTest.java new file mode 100644 index 000000000..30fbabf5e --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/ResponseInfoTest.java @@ -0,0 +1,41 @@ +package com.qiniu.android.http; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class ResponseInfoTest extends BaseTest { + + @Test + public void testCreate(){ + + ResponseInfo responseInfo = null; + + responseInfo = ResponseInfo.zeroSize(""); + assertTrue(responseInfo.statusCode == ResponseInfo.ZeroSizeFile); + + responseInfo = ResponseInfo.cancelled(); + assertTrue(responseInfo.statusCode == ResponseInfo.Cancelled); + + responseInfo = ResponseInfo.invalidArgument(""); + assertTrue(responseInfo.statusCode == ResponseInfo.InvalidArgument); + + responseInfo = ResponseInfo.invalidToken(""); + assertTrue(responseInfo.statusCode == ResponseInfo.InvalidToken); + + responseInfo = ResponseInfo.fileError(null); + assertTrue(responseInfo.statusCode == ResponseInfo.InvalidFile); + + responseInfo = ResponseInfo.networkError(""); + assertTrue(responseInfo.statusCode == ResponseInfo.NetworkError); + assertTrue(responseInfo.isNetworkBroken()); + assertTrue(responseInfo.needRetry()); + + responseInfo = ResponseInfo.localIOError(""); + assertTrue(responseInfo.statusCode == ResponseInfo.LocalIOError); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/connectCheck/ConnectCheckTest.java b/library/src/androidTest/java/com/qiniu/android/http/connectCheck/ConnectCheckTest.java new file mode 100644 index 000000000..c92f0528f --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/connectCheck/ConnectCheckTest.java @@ -0,0 +1,55 @@ +package com.qiniu.android.http.connectCheck; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.GlobalConfiguration; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class ConnectCheckTest extends BaseTest { + + @Test + public void testCheck() { + + int maxCount = 100; + int successCount = 0; + for (int i = 0; i < maxCount; i++) { + if (ConnectChecker.isConnected(ConnectChecker.check())) { + successCount += 1; + } + } + + assertEquals("maxCount:" + maxCount + " successCount:" + successCount, maxCount, successCount); + } + + @Test + public void testCustomCheckHosts() { + GlobalConfiguration.getInstance().connectCheckURLStrings = new String[]{"https://www.baidu.com", "https://www.google.com"}; + int maxCount = 100; + int successCount = 0; + for (int i = 0; i < maxCount; i++) { + if (ConnectChecker.isConnected(ConnectChecker.check())) { + successCount += 1; + } + } + + assertEquals("maxCount:" + maxCount + " successCount:" + successCount, maxCount, successCount); + } + + @Test + public void testNotConnected() { + GlobalConfiguration.getInstance().connectCheckURLStrings = new String[]{"https://www.test1.com", "https://www.test2.com"}; + int maxCount = 100; + int successCount = 0; + for (int i = 0; i < maxCount; i++) { + if (ConnectChecker.isConnected(ConnectChecker.check())) { + successCount += 1; + } + } + + assertEquals("maxCount:" + maxCount + " successCount:" + successCount, 0, successCount); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java new file mode 100644 index 000000000..34ce00c70 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java @@ -0,0 +1,129 @@ +package com.qiniu.android.http.dns; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.common.AutoZone; +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.UpToken; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.List; + +/** + * Created by jemy on 2019/8/20. + */ + +@RunWith(AndroidJUnit4.class) +public class DnsApiTest extends BaseTest { + + @Override @Before + public void setUp() throws Exception { + } + + @Test + public void testLocalLoad() { + + final String host = "uplog.qbox.me"; + final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); + dnsPrefetcher.localFetch(); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + List list = dnsPrefetcher.getInetAddressByHost(host); + if (list == null || list.size() == 0){ + return true; + } else { + return false; + } + } + }, 60); + + List addressList = dnsPrefetcher.getInetAddressByHost(host); + assertTrue(addressList.size() > 0); + } + + @Test + public void testRecover(){ + final String host = "uplog.qbox.me"; + + final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); + dnsPrefetcher.recoverCache(); + + List addressList = dnsPrefetcher.getInetAddressByHost(host); + assertTrue(addressList.size() > 0); + + dnsPrefetcher.invalidNetworkAddress(addressList.get(0)); + } + + @Test + public void testPreFetch() { + + final String host = "upload.qiniup.com"; + FixedZone fixedZone = new FixedZone(new String[]{host}); + + final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); + dnsPrefetcher.checkAndPrefetchDnsIfNeed(fixedZone, UpToken.parse(TestConfig.token_z0)); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + List list = dnsPrefetcher.getInetAddressByHost(host); + if (list == null || list.size() == 0){ + return true; + } else { + return false; + } + } + }, 60); + + List addressList = dnsPrefetcher.getInetAddressByHost(host); + assertTrue(addressList.size() > 0); + } + + @Test + public void testMutiThreadPrefetch(){ + + final AutoZone zone = new AutoZone(); + final TestParam param = new TestParam(); + + for (int i = 0; i < param.count; i++) { + new Thread(new Runnable() { + @Override + public void run() { + boolean isSuccess = DnsPrefetchTransaction.addDnsCheckAndPrefetchTransaction(zone, UpToken.parse(TestConfig.token_z0)); + synchronized (this){ + if (isSuccess){ + param.successCount += 1; + } + param.completeCount += 1; + } + } + }).start(); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (param.completeCount != param.count){ + return true; + } else { + return false; + } + } + }, 60); + + assertTrue((param.successCount <= 1)); + } + + private static class TestParam{ + int count = 100; + int successCount = 0; + int completeCount = 0; + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsCacheFileTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsCacheFileTest.java new file mode 100644 index 000000000..abb665ef6 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsCacheFileTest.java @@ -0,0 +1,66 @@ +package com.qiniu.android.http.dns; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.GlobalConfiguration; +import com.qiniu.android.utils.LogUtil; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.IOException; + +@RunWith(AndroidJUnit4.class) +public class DnsCacheFileTest extends BaseTest { + + @Test + public void testCreate(){ + try { + DnsCacheFile file = new DnsCacheFile(null); + if (file != null){ + assertTrue(false); + } + } catch (IOException e) { + assertTrue(true); + } + + + DnsCacheFile file = null; + try { + file = new DnsCacheFile(GlobalConfiguration.getInstance().dnsCacheDir); + } catch (IOException e) { + e.printStackTrace(); + } + LogUtil.i("DnsCacheFile name:" + file.getFileName()); + assertTrue(file != null); + + } + + @Test + public void testValue(){ + + String dataStringBefore = "123"; + byte[] dataBefore = dataStringBefore.getBytes(); + + DnsCacheFile file = null; + try { + file = new DnsCacheFile(GlobalConfiguration.getInstance().dnsCacheDir); + } catch (IOException e) { + e.printStackTrace(); + } + + file.set("key", dataBefore); + + byte[] dataAfter = file.get("key"); + String dataStringAfter = new String(dataAfter); + + assertTrue(dataStringBefore.equals(dataStringAfter)); + + + file.del("key"); + dataAfter = file.get("key"); + assertTrue(dataAfter == null); + + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java new file mode 100644 index 000000000..e1877eb06 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java @@ -0,0 +1,128 @@ +package com.qiniu.android.http.dns; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.common.AutoZone; +import com.qiniu.android.common.Zone; +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.UpToken; + +import org.junit.runner.RunWith; + + +/** + * Created by yangsen on 2020/6/9 + */ +@RunWith(AndroidJUnit4.class) +public class DnsTransactionTest extends BaseTest { + + private final int maxTestCount = 100; + private int completeCount = 0; + private int successCount = 0; + + public void testLocalLoad(){ + + completeCount = 0; + successCount = 0; + + for (int i = 0; i < maxTestCount; i++) { + new Thread(new Runnable() { + @Override + public void run() { + + boolean isSuccess = DnsPrefetchTransaction.addDnsLocalLoadTransaction(); + if (isSuccess){ + successCount += 1; + } + completeCount += 1; + } + }).start(); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (completeCount < maxTestCount) { + return true; + } else { + return false; + } + } + }, 60); + + assertTrue(successCount < 2); + } + + + public void test_CheckAndPrefetch(){ + + completeCount = 0; + successCount = 0; + + final Zone zone = new AutoZone(); + for (int i = 0; i < maxTestCount; i++) { + new Thread(new Runnable() { + @Override + public void run() { + + boolean isSuccess = DnsPrefetchTransaction.addDnsCheckAndPrefetchTransaction(zone, UpToken.parse(TestConfig.token_z0)); + synchronized (this) { + if (isSuccess) { + successCount += 1; + } + completeCount += 1; + } + } + }).start(); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (completeCount < maxTestCount) { + return true; + } else { + return false; + } + } + }, 60); + + assertTrue("successCount:" + successCount, successCount < 3); + } + + + public void testCheckWhetherCachedValid(){ + + completeCount = 0; + successCount = 0; + + final Zone zone = new AutoZone(); + for (int i = 0; i < maxTestCount; i++) { + new Thread(new Runnable() { + @Override + public void run() { + + boolean isSuccess = DnsPrefetchTransaction.setDnsCheckWhetherCachedValidTransactionAction(); + if (isSuccess){ + successCount += 1; + } + completeCount += 1; + } + }).start(); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (completeCount < maxTestCount) { + return true; + } else { + return false; + } + } + }, 60); + + assertTrue(successCount < 2); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/HappyDnsTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/HappyDnsTest.java new file mode 100644 index 000000000..56ff2b79d --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/HappyDnsTest.java @@ -0,0 +1,34 @@ +package com.qiniu.android.http.dns; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.List; + +/** + * Created by yangsen on 2020/6/8 + */ +@RunWith(AndroidJUnit4.class) +public class HappyDnsTest extends BaseTest { + + @Test + public void testDns(){ + + HappyDns happyDns = new HappyDns(); + List inetAddressList = new ArrayList<>(); + + try { + inetAddressList = happyDns.lookup("qiniu.com"); + } catch (UnknownHostException e) { + e.printStackTrace(); + } + + assertTrue(inetAddressList.size() > 0); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/SystemDnsTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/SystemDnsTest.java new file mode 100644 index 000000000..f7b5226e1 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/SystemDnsTest.java @@ -0,0 +1,43 @@ +package com.qiniu.android.http.dns; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.utils.Utils; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.UnknownHostException; +import java.util.List; + +@RunWith(AndroidJUnit4.class) +public class SystemDnsTest extends BaseTest { + + @Test + public void testDnsLookup() { + SystemDns dns = new SystemDns(5); + try { + List result = dns.lookup("upload.qiniup.com"); + assertTrue("testDnsLookup fail:", result != null && result.size() > 0); + } catch (UnknownHostException e) { + e.printStackTrace(); + fail("testDnsLookup fail because:" + e.getMessage()); + } + } + + @Test + public void testDnsTimeout() { + long start = Utils.currentSecondTimestamp(); + int timeout = 5; + SystemDns dns = new SystemDns(timeout); + try { + List result = dns.lookup("a.a.a.cn"); + assertTrue("testDnsTimeout fail:", result == null || result.size() == 0); + } catch (UnknownHostException e) { + e.printStackTrace(); + } + long end = Utils.currentSecondTimestamp(); + assertTrue("testDnsTimeout fail because timeout to long", end <= (start + timeout + 1)); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/request/RequestTransactionTest.java b/library/src/androidTest/java/com/qiniu/android/http/request/RequestTransactionTest.java new file mode 100644 index 000000000..d8b35b3f6 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/request/RequestTransactionTest.java @@ -0,0 +1,201 @@ +package com.qiniu.android.http.request; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.http.request.handler.RequestProgressHandler; +import com.qiniu.android.http.metrics.UploadRegionRequestMetrics; +import com.qiniu.android.BaseTest; +import com.qiniu.android.storage.Configuration; +import com.qiniu.android.storage.UpToken; +import com.qiniu.android.storage.UploadOptions; +import com.qiniu.android.utils.LogUtil; + +import junit.framework.Assert; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.ArrayList; + + +@RunWith(AndroidJUnit4.class) +public class RequestTransactionTest extends BaseTest { + + @Test + public void testUCQuery(){ + + UpToken token = UpToken.parse(TestConfig.token_z0); + + ArrayList hosts = new ArrayList(); + hosts.add("uc.qbox.me"); + + final WaitCondition waitCondition = new WaitCondition(); + + RequestTransaction requestTransaction = new RequestTransaction(hosts, token); + requestTransaction.queryUploadHosts(true, new RequestTransaction.RequestCompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + Assert.assertTrue("pass", responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + @Test + public void testUploadForm(){ + + final WaitCondition waitCondition = new WaitCondition(); + + UpToken token = UpToken.parse(TestConfig.token_z0); + + ArrayList hosts = new ArrayList(); + hosts.add("upload.qiniup.com"); + + byte[] data = "你好".getBytes(); + RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), + UploadOptions.defaultOptions(), + hosts, null, + "android-transaction-form", + token); + requestTransaction.uploadFormData(data, null, true, new RequestProgressHandler() { + @Override + public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { + LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); + } + }, new RequestTransaction.RequestCompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + Assert.assertTrue("pass", responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + + @Test + public void testUploadBlock(){ + + final WaitCondition waitCondition = new WaitCondition(); + + makeBlock(new RequestTransaction.RequestCompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + + if (responseInfo.isOK()){ + + String ct = null; + try { + ct = response.getString("ctx"); + } catch (JSONException e) {} + + if (ct == null) { + Assert.assertTrue("pass", false); + waitCondition.shouldWait = false; + return; + } + + uploadChunk(ct, new RequestTransaction.RequestCompleteHandler(){ + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + + if (responseInfo.isOK()){ + + String ct_02 = null; + try { + ct_02 = response.getString("ctx"); + } catch (JSONException e) {} + + if (ct_02 == null) { + Assert.assertTrue("pass", false); + waitCondition.shouldWait = false; + return; + } + + makeFile(new String[]{ct_02}, new RequestTransaction.RequestCompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + Assert.assertTrue("pass", responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + } else { + Assert.assertTrue("pass", false); + waitCondition.shouldWait = false; + } + } + }); + } else { + Assert.fail("fail"); + waitCondition.shouldWait = false; + } + } + }); + + wait(waitCondition, 60); + } + + private void makeBlock(RequestTransaction.RequestCompleteHandler completeHandler){ + UpToken token = UpToken.parse(TestConfig.token_z0); + + ArrayList hosts = new ArrayList(); + hosts.add("upload.qiniup.com"); + + byte[] data = new byte[2*1024*1024]; + RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts, null, "android-transaction-block", token); + requestTransaction.makeBlock(0, 3*1024*1024, data, true, new RequestProgressHandler() { + @Override + public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { + LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); + } + }, completeHandler); + } + + private void uploadChunk(String ct, RequestTransaction.RequestCompleteHandler completeHandler){ + UpToken token = UpToken.parse(TestConfig.token_z0); + + ArrayList hosts = new ArrayList(); + hosts.add("upload.qiniup.com"); + + byte[] data = new byte[1*1024*1024]; + RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts, null,"android-transaction-block", token); + requestTransaction.uploadChunk(ct,0, data, 2*1024*1024,true, new RequestProgressHandler() { + @Override + public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { + LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); + } + }, completeHandler); + } + + private void makeFile(String[] blockContexts, RequestTransaction.RequestCompleteHandler completeHandler){ + UpToken token = UpToken.parse(TestConfig.token_z0); + + ArrayList hosts = new ArrayList(); + hosts.add("upload.qiniup.com"); + + RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts,null, "android-transaction-block", token); + requestTransaction.makeFile(3*1024*1024, "android-transaction-block-fileName", blockContexts, true, completeHandler); + } + + @Test + public void testMakeFileError(){ + final WaitCondition waitCondition = new WaitCondition(); + + makeFile(null, new RequestTransaction.RequestCompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { + Assert.assertTrue("pass", !responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/request/httpclient/SystemHttpClientTest.java b/library/src/androidTest/java/com/qiniu/android/http/request/httpclient/SystemHttpClientTest.java new file mode 100644 index 000000000..ee73936f4 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/request/httpclient/SystemHttpClientTest.java @@ -0,0 +1,120 @@ +package com.qiniu.android.http.request.httpclient; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.http.request.Request; +import com.qiniu.android.http.request.IRequestClient; +import com.qiniu.android.http.metrics.UploadSingleRequestMetrics; +import com.qiniu.android.BaseTest; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class SystemHttpClientTest extends BaseTest { + + @Test + public void testGet() { + + final WaitCondition waitCondition = new WaitCondition(); + + Request request = new Request("https://uc.qbox.me/v3/query?ak=jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu&bucket=zone0-space", + null, null, null, 15); + + SystemHttpClient client = new SystemHttpClient(); + client.request(request, true, null, null, new IRequestClient.CompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { + assertTrue("pass", responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + @Test + public void testSyncGet() { + + final WaitCondition waitCondition = new WaitCondition(); + + Request request = new Request("https://uc.qbox.me/v3/query?ak=jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu&bucket=zone0-space", + null, null, null, 15); + + SystemHttpClient client = new SystemHttpClient(); + client.request(request, false, null, null, new IRequestClient.CompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { + assertTrue("pass", responseInfo.isOK()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + @Test + public void testPostRequest() { + + final WaitCondition waitCondition = new WaitCondition(); + + Request request = new Request("http://www.baidu.com/", + Request.HttpMethodPOST, null, "hello".getBytes(), 15); + + SystemHttpClient client = new SystemHttpClient(); + client.request(request, true, null, null, new IRequestClient.CompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { + + assertFalse("pass", responseInfo.isServerError()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + @Test + public void testSyncPostRequest() { + + final WaitCondition waitCondition = new WaitCondition(); + + Request request = new Request("http://www.baidu.com/", + Request.HttpMethodPOST, null, "hello".getBytes(), 15); + + SystemHttpClient client = new SystemHttpClient(); + client.request(request, false, null, null, new IRequestClient.CompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { + + assertFalse("pass", responseInfo.isServerError()); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } + + @Test + public void testPostRequestError() { + + final WaitCondition waitCondition = new WaitCondition(); + + Request request = new Request("http://www.baidu.com/", + Request.HttpMethodPOST, null, "hello".getBytes(), 15); + + SystemHttpClient client = new SystemHttpClient(); + client.request(null, true, null, null, new IRequestClient.CompleteHandler() { + @Override + public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { + + assertTrue("pass", responseInfo.statusCode == ResponseInfo.InvalidArgument); + waitCondition.shouldWait = false; + } + }); + + wait(waitCondition, 60); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadDomainRegionTest.java b/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadDomainRegionTest.java new file mode 100644 index 000000000..256db5dab --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadDomainRegionTest.java @@ -0,0 +1,36 @@ +package com.qiniu.android.http.serverRegion; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.http.request.IUploadServer; +import com.qiniu.android.http.request.UploadRequestState; +import com.qiniu.android.BaseTest; +import com.qiniu.android.utils.Utils; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class UploadDomainRegionTest extends BaseTest { + + @Test + public void testGetOneServer(){ + + String host = "baidu.com"; + String type = Utils.getIpType(null, host); + FixedZone zone = new FixedZone(new String[]{host}); + + UploadDomainRegion region = new UploadDomainRegion(); + region.setupRegionData(zone.getZonesInfo(null).zonesInfo.get(0)); + + UploadServerFreezeManager.getInstance().freezeType(type, 100); + + UploadRequestState state = new UploadRequestState(); + state.setUseOldServer(false); + IUploadServer server = region.getNextServer(state, null, null); + + assertNotNull(server); + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadServerFreezeManagerTest.java b/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadServerFreezeManagerTest.java new file mode 100644 index 000000000..d77c75bc3 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/http/serverRegion/UploadServerFreezeManagerTest.java @@ -0,0 +1,39 @@ +package com.qiniu.android.http.serverRegion; + + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class UploadServerFreezeManagerTest extends BaseTest { + + @Test + public void testFreeze() { + + String host = "baidu.com"; + String type = host; + UploadServerFreezeManager.getInstance().freezeType(type, 10); + + boolean isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); + assertTrue(isFrozen); + } + + @Test + public void testUnfreeze() { + + String host = "baidu.com"; + String type = host; + UploadServerFreezeManager.getInstance().freezeType(type, 10); + + boolean isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); + assertTrue(isFrozen); + + UploadServerFreezeManager.getInstance().unfreezeType(type); + isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); + assertTrue(isFrozen == false); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/serverRegion/HttpServerManagerTest.java b/library/src/androidTest/java/com/qiniu/android/serverRegion/HttpServerManagerTest.java index d3a17dbf2..8f51ea993 100644 --- a/library/src/androidTest/java/com/qiniu/android/serverRegion/HttpServerManagerTest.java +++ b/library/src/androidTest/java/com/qiniu/android/serverRegion/HttpServerManagerTest.java @@ -1,10 +1,17 @@ package com.qiniu.android.serverRegion; +import androidx.test.ext.junit.runners.AndroidJUnit4; + import com.qiniu.android.BaseTest; import com.qiniu.android.http.serverRegion.HttpServerManager; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) public class HttpServerManagerTest extends BaseTest { + @Test public void testServer() { String host = "up.qiniu.com"; String ip = "192.168.1.1"; diff --git a/library/src/androidTest/java/com/qiniu/android/storage/CancelTest.java b/library/src/androidTest/java/com/qiniu/android/storage/CancelTest.java new file mode 100644 index 000000000..fa4aea19d --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/CancelTest.java @@ -0,0 +1,318 @@ +package com.qiniu.android.storage; + + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TempFile; +import com.qiniu.android.TestConfig; +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.common.ZoneInfo; +import com.qiniu.android.common.ZonesInfo; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.LogUtil; + +import junit.framework.Assert; + +import org.json.JSONObject; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +/** + * Created by Simon on 2015/4/15. + */ +@RunWith(AndroidJUnit4.class) +public class CancelTest extends BaseTest { + private volatile UploadManager uploadManager; + private volatile UploadOptions options; + + @Before + public void setUp() throws Exception { + File f = File.createTempFile("qiniutest", "b"); + String folder = f.getParent(); + FileRecorder fr = new FileRecorder(folder); + uploadManager = new UploadManager(fr); + } + + @Test + public void testFile() throws Throwable { + Temp[] ts = new Temp[]{templateFile(8 * 1024 + 1, 0.6)}; + checkTemp(ts, "testFile"); + } + + @Test + public void testMultiFile() throws Throwable { + Temp[] ts = new Temp[]{templateFile(400, 0.01), templateFile(700, 0.02), templateFile(1024, 0.02), templateFile(4 * 1024, 0.02), templateFile(8 * 1024 + 1, 0.2)}; + checkTemp(ts, "testFile"); + } + +// public void testData() throws Throwable { +// Temp[] ts = new Temp[]{templateData(400, 0.2), templateData(700, 0.2), templateData(1024, 0.51), templateData(4 * 1024 + 785, 0.5), templateData(4 * 1024, 0.5), templateData(8 * 1024, 0.6)}; +// checkTemp(ts, "testData"); +// } + + private void checkTemp(Temp[] ts, String type) { + int failedCount = 0; + Temp tt = null; + + for (int i = 0; i < ts.length; i++) { + Temp t = ts[i]; + boolean b = t.expectKey.equals(t.key) && t.info.isCancelled() && (t.resp == null); + if (!b) { + tt = t; + failedCount++; + } + } + + LogUtil.d(type + " " + failedCount); + if (failedCount > ts.length / 2) { + String info = type + ": 共 " + ts.length + "个测试，至多允许 " + ts.length / 2 + " 失败，实际失败 " + failedCount + " 个： " + tt.info.toString(); + Assert.assertEquals(info, tt.expectKey, tt.key); + } + } + + + private Temp templateFile(final int size, final double pos) throws Throwable { + final CountDownLatch signal = new CountDownLatch(1); + final File tempFile = TempFile.createFile(size); + final String expectKey = "file_" + size; + Map params = new HashMap(); + params.put("x:a", "test"); + params.put("x:b", "test2"); + + final Temp temp = new Temp(); + temp.cancelled = false; + + Thread t = new Thread() { + public void run() { + try { + Thread.sleep(8 * 60 * 1000); + temp.cancelled = true; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }; + t.setDaemon(true); + t.start(); + + final WaitCondition waitCondition = new WaitCondition(); + + options = new UploadOptions(params, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + if (percent >= pos) { + temp.cancelled = true; + } + LogUtil.i(pos + ": progress " + percent); + } + }, new UpCancellationSignal() { + @Override + public boolean isCancelled() { + return temp.cancelled; + } + }); + + uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + temp.expectKey = expectKey; + temp.key = k; + temp.info = rinfo; + temp.resp = response; + signal.countDown(); + LogUtil.i(k + rinfo); + + waitCondition.shouldWait = false; + } + }, options); + + wait(waitCondition, 10 * 60); + assertTrue(temp.info != null); + assertTrue(temp.info.statusCode == ResponseInfo.Cancelled); + + + waitCondition.shouldWait = true; + + // 断点续传 + options = new UploadOptions(params, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + LogUtil.i(pos + ": progress " + percent); + } + }, null); + uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + temp.expectKey = expectKey; + temp.key = k; + temp.info = rinfo; + temp.resp = response; + signal.countDown(); + LogUtil.i(k + rinfo); + + waitCondition.shouldWait = false; + } + }, options); + + wait(waitCondition, 10 * 60); + + assertTrue(temp.info != null); + assertTrue(temp.info.isOK()); + + TempFile.remove(tempFile); + return temp; + } + + private Temp templateData(final int size, final double pos) throws Throwable { + final CountDownLatch signal = new CountDownLatch(1); + final byte[] tempDate = TempFile.getByte(1024 * size); + final String expectKey = "data_" + UUID.randomUUID().toString(); + Map params = new HashMap(); + params.put("x:a", "test"); + params.put("x:b", "test2"); + + final Temp temp = new Temp(); + temp.cancelled = false; + + Thread t = new Thread() { + public void run() { + try { + Thread.sleep(8 * 60 * 1000); + temp.cancelled = true; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }; + t.setDaemon(true); + t.start(); + + options = new UploadOptions(params, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + if (percent >= pos) { + temp.cancelled = true; + } + LogUtil.i(pos + ": progress " + percent); + } + }, new UpCancellationSignal() { + @Override + public boolean isCancelled() { + return temp.cancelled; + } + }); + + uploadManager.put(tempDate, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + temp.expectKey = expectKey; + temp.key = k; + temp.info = rinfo; + temp.resp = response; + signal.countDown(); + LogUtil.i(k + rinfo); + } + }, options); + + + try { + signal.await(570, TimeUnit.SECONDS); // wait for callback + Assert.assertNotNull("timeout", temp.info); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return temp; + } + + @Test + public void testSwitchRegion() throws IOException { + + final CountDownLatch signal = new CountDownLatch(1); + final File tempFile = TempFile.createFile(5 * 1024); + final String expectKey = "file_" + UUID.randomUUID().toString(); + Map params = new HashMap(); + params.put("x:a", "test"); + params.put("x:b", "test2"); + + final Temp temp = new Temp(); + temp.cancelled = false; + + Thread t = new Thread() { + public void run() { + try { + Thread.sleep(8 * 60 * 1000); + temp.cancelled = true; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }; + t.setDaemon(true); + t.start(); + + final WaitCondition waitCondition = new WaitCondition(); + + options = new UploadOptions(params, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + LogUtil.i("progress " + percent); + } + }, null); + + File f = File.createTempFile("qiniutest", "b"); + String folder = f.getParent(); + FileRecorder fr = new FileRecorder(folder); + + ArrayList hostArray0 = new ArrayList<>(); + hostArray0.add("mock1.up.qiniup.com"); + ZoneInfo zoneInfo0 = ZoneInfo.buildInfo(hostArray0, null, null); + ArrayList hostArray1 = new ArrayList<>(); + hostArray1.add("up-na0.qiniup.com"); + ZoneInfo zoneInfo1 = ZoneInfo.buildInfo(hostArray1, null, null); + + ArrayList zoneInfoArray = new ArrayList<>(); + zoneInfoArray.add(zoneInfo0); + zoneInfoArray.add(zoneInfo1); + ZonesInfo zonesInfo = new ZonesInfo(zoneInfoArray); + FixedZone zone = new FixedZone(zonesInfo); + + Configuration config = new Configuration.Builder().recorder(fr).zone(zone).build(); + + UploadManager uploadManager = new UploadManager(config); + uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + temp.expectKey = expectKey; + temp.key = k; + temp.info = rinfo; + temp.resp = response; + signal.countDown(); + LogUtil.i(k + rinfo); + + waitCondition.shouldWait = false; + } + }, options); + + wait(waitCondition, 10 * 60); + + assertTrue(temp.info != null); + assertTrue(temp.info.toString(), temp.info.isOK()); + + TempFile.remove(tempFile); + } + + private static class Temp { + volatile ResponseInfo info; + volatile JSONObject resp; + volatile String key; + volatile String expectKey; + volatile boolean cancelled; + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/ComplexUploadSceneTest.java b/library/src/androidTest/java/com/qiniu/android/storage/ComplexUploadSceneTest.java new file mode 100644 index 000000000..3b1c6407e --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/ComplexUploadSceneTest.java @@ -0,0 +1,139 @@ +package com.qiniu.android.storage; + +import android.util.Log; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TempFile; +import com.qiniu.android.http.ResponseInfo; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.util.concurrent.CountDownLatch; + +@RunWith(AndroidJUnit4.class) +public class ComplexUploadSceneTest extends UploadBaseTest { + + private final CountDownLatch signal = new CountDownLatch(1); + + @Test + public void testMutiUploadV1() { + + final int maxCount = 40; + + final TestParam param = new TestParam(); + param.completeCount = 0; + param.successCount = 0; + + final int start = 37; + for (int i = start; i < maxCount; i++) { + Configuration config = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .concurrentTaskCount(3) + .chunkSize((i % 4 + 1) * 1024 * 1024 + i) + .build(); + + int size = (i + 1) * 1024; + final String keyUp = "android_complex_upload_v1_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size); + } catch (IOException e) { + continue; + } + + UploadInfo info = new UploadInfo<>(file); + info.configWithFile(file); + upload(info, keyUp, config, null, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + synchronized (param) { + param.completeCount += 1; + if (info != null && info.isOK()) { + param.successCount += 1; + } + if (param.completeCount == (maxCount - start)) { + signal.countDown(); + } + } + Log.d("upload key:" + keyUp, "complex_upload_v1 response: " + info); + } + }); + } + + try { + signal.await(); // wait for callback + } catch (InterruptedException e) { + } + + Log.d("ComplexUploadSceneTest", "complex_upload_v1 successCount: " + param.successCount); + assertTrue("success count" + param.successCount, param.successCount == param.completeCount); + } + + @Test + public void testMutiUploadV2() { + + final int maxCount = 40; + + final TestParam param = new TestParam(); + param.completeCount = 0; + param.successCount = 0; + + final int start = 37; + for (int i = start; i < maxCount; i++) { + Configuration config = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .concurrentTaskCount(3) + .chunkSize((i % 4 + 1) * 1024 * 1024 + i) + .build(); + + int size = (i + 1) * 1024; + final String keyUp = "android_complex_upload_v2_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size); + } catch (IOException e) { + continue; + } + + UploadInfo info = new UploadInfo<>(file); + info.configWithFile(file); + upload(info, keyUp, config, null, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + synchronized (param) { + param.completeCount += 1; + if (info != null && (info.isOK() || info.statusCode == 614)) { + param.successCount += 1; + } + if (param.completeCount == (maxCount - start)) { + signal.countDown(); + } + } + Log.d("upload key:" + keyUp, "complex_upload_v2 response: " + info); + } + }); + } + + try { + signal.await(); // wait for callback + } catch (InterruptedException e) { + } + + Log.d("ComplexUploadSceneTest", "complex_upload_v2 successCount: " + param.successCount); + assertTrue("success count" + param.successCount, param.successCount == (param.completeCount)); + } + + + private class TestParam { + int successCount = 0; + int completeCount = 0; + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/ConcurrentResumeUploadTest.java b/library/src/androidTest/java/com/qiniu/android/storage/ConcurrentResumeUploadTest.java new file mode 100644 index 000000000..27594b885 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/ConcurrentResumeUploadTest.java @@ -0,0 +1,342 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TempFile; +import com.qiniu.android.http.ResponseInfo; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.util.Date; + + +/** + * Created by yangsen on 2020/5/27 + */ +@RunWith(AndroidJUnit4.class) +public class ConcurrentResumeUploadTest extends UploadFlowTest { + + @Test + public void testSwitchRegionV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + int[] sizeArray = {5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_switch_region_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + switchRegionTestWithFile(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testCancelV1() { + float cancelPercent = (float) 0.5; + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + int[] sizeArray = {10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_cancel_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + cancelTest((long) (size * cancelPercent), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_http_v1_new_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpsV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_https_v1_new_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testReuploadV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .chunkSize(1024 * 1024) + .build(); + int[] sizeArray = {30000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_reupload_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + reuploadUploadTest((long) (size * 0.5), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testNoKeyV1() { + int size = 600; + String key = "android_concurrent_resume_no_key_v1_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void test0kV1() { + int size = 0; + String key = "android_concurrent_resume_0k_v1_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void testSwitchRegionV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .chunkSize(4 * 1024 * 1024) + .useHttps(true) + .build(); + int[] sizeArray = {5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_switch_region_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + switchRegionTestWithFile(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testCancelV2() { + float cancelPercent = (float) 0.5; + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .chunkSize(4 * 1024 * 1024) + .useHttps(true) + .build(); + int[] sizeArray = {10000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_cancel_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + cancelTest((long) (size * cancelPercent), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .chunkSize(4 * 1024 * 1024) + .useHttps(false) + .build(); + int[] sizeArray = {500, 2000, 4000, 5000, 8000, 20000}; + long timestamp = new Date().getTime(); + for (int size : sizeArray) { + String key = "android_concurrent_resume_http_v2_" + timestamp + "_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpsV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(true) + .chunkSize(4 * 1024 * 1024) + .build(); + int[] sizeArray = {500, 2000, 4000, 5000, 8000, 20000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_https_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testReuploadV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(true) + .chunkSize(4 * 1024 * 1024) + .build(); + int[] sizeArray = {30000}; + for (int size : sizeArray) { + String key = "android_concurrent_resume_reupload_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + reuploadUploadTest((long) (size * 0.7), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testNoKeyV2() { + int size = 600; + String key = "android_concurrent_resume_no_key_v2_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void test0kV2() { + int size = 0; + String key = "android_concurrent_resume_0k_v2_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); + + TempFile.remove(file); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/FormUploadTest.java b/library/src/androidTest/java/com/qiniu/android/storage/FormUploadTest.java new file mode 100644 index 000000000..5818dcfd0 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/FormUploadTest.java @@ -0,0 +1,246 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TempFile; +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.http.UrlConverter; + +import junit.framework.Assert; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +@RunWith(AndroidJUnit4.class) +public class FormUploadTest extends UploadFlowTest { + + @Test + public void testSwitchRegion() { + Configuration configuration = new Configuration.Builder() + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + int[] sizeArray = {5, 50, 200, 500, 800, 1000, 2000, 3000, 4000}; + for (int size : sizeArray) { + String key = "android_Form_switch_region_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + switchRegionTestWithFile(file, key, configuration, null); + } + } + + @Test + public void testCancel() { + GlobalConfiguration.getInstance().partialHostFrozenTime = 20*60; + + float cancelPercent = (float) 0.2; + Configuration configuration = new Configuration.Builder() + .connectTimeout(60) + .responseTimeout(30) + .retryMax(0) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + int[] sizeArray = {2000, 3000, 4000}; + for (int size : sizeArray) { + String key = "android_form_cancel_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + Assert.fail(e.getMessage()); + } + cancelTest((long) (size * cancelPercent), file, key, configuration, null); + } + } + + @Test + public void testHttp() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(false) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_form_http" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertSuccessResult(file, key, configuration, null); + } + } + + @Test + public void testHttps() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(true) + .useHttps(true) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_form_https" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertSuccessResult(file, key, configuration, null); + } + } + + @Test + public void testSmall() { + Map params = new HashMap(); + params.put("x:foo", "foo"); + params.put("x:bar", "bar"); + //mime type + final String mimeType = "text/plain"; + final UploadOptions options = new UploadOptions(params, mimeType, true, null, null); + + String key = "android_small"; + File file = null; + try { + file = TempFile.createFile(10, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertSuccessResult(file, key, null, options); + } + + @Test + public void test100up() { + int count = 100; + for (int i = 1; i < count; i++) { + String key = "android_form_100_UP_" + i + "k"; + File file = null; + try { + file = TempFile.createFile(10, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertSuccessResult(file, key, null, null); + } + } + + @Test + public void testUpUnAuth() { + String key = "android_unAuth"; + File file = null; + try { + file = TempFile.createFile(10, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "noAuth", "android_form_no_auth", null, null); + } + + @Test + public void testNoData() { + String key = "android_noData"; + File file = null; + try { + file = TempFile.createFile(0, key); + } catch (IOException e) { + Assert.assertTrue(e.getMessage(), false); + } + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, null, null); + } + + @Test + public void testNoToken() { + String key = "android_form_no_token"; + File file = null; + try { + file = TempFile.createFile(5 * 1024, key); + } catch (IOException e) { + e.printStackTrace(); + } + + uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, null, key, null, null); + + uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "", key, null, null); + + uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "ABC", key, null, null); + + TempFile.remove(file); + } + + @Test + public void testNoKey() { + String key = "android_form_no_key"; + File file = null; + try { + file = TempFile.createFile(5 * 1024, key); + } catch (IOException e) { + e.printStackTrace(); + } + + uploadFileAndAssertSuccessResult(file, null, null, null); + + TempFile.remove(file); + } + + @Test + public void testUrlConvert() { + String fileKey = "android_form_url_convert_file_new"; + File file = null; + try { + file = TempFile.createFile(5, fileKey); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configuration = new Configuration.Builder() + .useHttps(false) + .zone(new FixedZone(new String[]{"upnono-na0.qiniu.com", "upnono-na0.qiniu.com"})) + .urlConverter(new UrlConverter() { + @Override + public String convert(String url) { + return url.replace("upnono", "up"); + } + }) + .build(); + uploadFileAndAssertSuccessResult(file, fileKey, configuration, null); + } + + @Test + public void testCustomParam() { + + Map userParam = new HashMap<>(); + userParam.put("foo", "foo_value"); + userParam.put("bar", "bar_value"); + + Map metaParam = new HashMap<>(); + metaParam.put("0000", "meta_value_0"); + metaParam.put("x-qn-meta-aaa", "meta_value_1"); + metaParam.put("x-qn-meta-key-2", "meta_value_2"); + + UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); + + String fileKey = "android_form_custom_param_file"; + File file = null; + try { + file = TempFile.createFile(5, fileKey); + } catch (IOException e) { + e.printStackTrace(); + } + uploadFileAndAssertSuccessResult(file, fileKey, null, options); + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/ResumeUploadTest.java b/library/src/androidTest/java/com/qiniu/android/storage/ResumeUploadTest.java new file mode 100644 index 000000000..080b955bf --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/ResumeUploadTest.java @@ -0,0 +1,401 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TempFile; +import com.qiniu.android.http.ResponseInfo; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +@RunWith(AndroidJUnit4.class) +public class ResumeUploadTest extends UploadFlowTest { + + @Test + public void testSwitchRegionV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + int[] sizeArray = {1000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_switch_region_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + switchRegionTestWithFile(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testCancelV1() { + float cancelPercent = (float) 0.5; + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + int[] sizeArray = {10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_cancel_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + cancelTest((long) (size * cancelPercent), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_http_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpsV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + int[] sizeArray = {500, 3000, 4000, 7000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_https_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testReuploadV1() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .chunkSize(1024 * 1024) + .build(); + int[] sizeArray = {30000}; + for (int size : sizeArray) { + String key = "android_resume_reupload_v1_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + reuploadUploadTest((long) (size * 0.5), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testNoKeyV1() { + int size = 600; + String key = "android_resume_no_key_v1_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void test0kV1() { + int size = 0; + String key = "android_resume_0k_v1_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void testCustomParamV1() { + + Map userParam = new HashMap<>(); + userParam.put("foo", "foo_value"); + userParam.put("bar", "bar_value"); + + Map metaParam = new HashMap<>(); + metaParam.put("0000", "meta_value_0"); + metaParam.put("x-qn-meta-aaa", "meta_value_1"); + metaParam.put("x-qn-meta-key-2", "meta_value_2"); + + UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); + + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + + String key = "android_resume_custom_param_v1"; + File file = null; + try { + file = TempFile.createFile(5 * 1024, key); + } catch (IOException e) { + e.printStackTrace(); + } + + uploadFileAndAssertSuccessResult(file, key, configuration, options); + } + + @Test + public void testSwitchRegionV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .chunkSize(4 * 1024 * 1024) + .useHttps(true) + .build(); + int[] sizeArray = {5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_switch_region_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + switchRegionTestWithFile(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testCancelV2() { + float cancelPercent = (float) 0.5; + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .chunkSize(4 * 1024 * 1024) + .useHttps(true) + .build(); + int[] sizeArray = {10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_cancel_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + cancelTest((long) (size * cancelPercent), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .chunkSize(4 * 1024 * 1024) + .useHttps(false) + .build(); + int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_http_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testHttpsV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .chunkSize(4 * 1024 * 1024) + .useHttps(true) + .build(); + int[] sizeArray = {500, 3000, 4000, 7000, 10000, 20000}; + for (int size : sizeArray) { + String key = "android_resume_https_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + uploadFileAndAssertSuccessResult(file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testReuploadV2() { + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .useHttps(true) + .chunkSize(4 * 1024 * 1024) + .build(); + int[] sizeArray = {30000}; + for (int size : sizeArray) { + String key = "android_resume_reupload_v2_" + size + "k"; + try { + File file = TempFile.createFile(size, key); + reuploadUploadTest((long) (size * 0.7), file, key, configuration, null); + TempFile.remove(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + @Test + public void testNoKeyV2() { + int size = 600; + String key = "android_resume_reupload_v2_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void test0kV2() { + int size = 0; + String key = "android_resume_0k_v2_" + size + "k"; + File file = null; + try { + file = TempFile.createFile(size, key); + } catch (IOException e) { + e.printStackTrace(); + } + + Configuration configurationHttp = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .useHttps(false) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); + + Configuration configurationHttps = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .useHttps(true) + .build(); + uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); + + TempFile.remove(file); + } + + @Test + public void testCustomParamV2() { + + Map userParam = new HashMap<>(); + userParam.put("foo", "foo_value"); + userParam.put("bar", "bar_value"); + + Map metaParam = new HashMap<>(); + metaParam.put("0000", "meta_value_0"); + metaParam.put("x-qn-meta-aaa", "meta_value_1"); + metaParam.put("x-qn-meta-key-2", "meta_value_2"); + + UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); + + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) + .useConcurrentResumeUpload(false) + .chunkSize(4 * 1024 * 1024) + .useHttps(false) + .build(); + + String key = "android_resume_custom_param_v2"; + File file = null; + try { + file = TempFile.createFile(5 * 1024, key); + } catch (IOException e) { + e.printStackTrace(); + } + + uploadFileAndAssertSuccessResult(file, key, configuration, options); + } +} \ No newline at end of file diff --git a/library/src/androidTest/java/com/qiniu/android/storage/RetryTest.java b/library/src/androidTest/java/com/qiniu/android/storage/RetryTest.java new file mode 100644 index 000000000..5413cc72a --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/RetryTest.java @@ -0,0 +1,211 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TempFile; +import com.qiniu.android.TestConfig; +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.common.Zone; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.LogUtil; + +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; + +/** + * Created by yangsen on 2020/6/3 + */ +@RunWith(AndroidJUnit4.class) +public class RetryTest extends BaseTest { + + @Test + public void testUpload() { + + final TestParam param = new TestParam(); + param.count = 10; + + for (int i = 0; i < param.count; i++) { + + final int i_p = i; + + new Thread(new Runnable() { + @Override + public void run() { + + try { + template((i_p + 1), true, new CompleteHandler() { + @Override + public void complete(boolean isSuccess) { + + synchronized (this){ + if (isSuccess){ + param.successCount += 1; + } + param.completeCount += 1; + } + + } + }); + } catch (Throwable ignored) { + } + + } + }).start(); + + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (param.completeCount != param.count){ + return true; + } else { + return false; + } + } + }, 600 * 10); + + assertTrue((param.completeCount == param.successCount)); + } + + @Test + public void testUploadError(){ + final TestParam param = new TestParam(); + param.count = 10; + + for (int i = 0; i < param.count; i++) { + + final int i_p = i; + + new Thread(new Runnable() { + @Override + public void run() { + + try { + template((i_p + 1), false, new CompleteHandler() { + @Override + public void complete(boolean isSuccess) { + + synchronized (this){ + if (isSuccess){ + param.successCount += 1; + } + param.completeCount += 1; + } + + } + }); + } catch (Throwable ignored) { + } + + } + }).start(); + + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (param.completeCount != param.count){ + return true; + } else { + return false; + } + } + }, 600 * 10); + + assertTrue((param.successCount == 0)); + } + + private void template(int size, boolean hasValidHost, final CompleteHandler completeHandler) throws Throwable{ + + final WaitCondition waitCondition = new WaitCondition(); + + final String expectKey = "android-retry-" + size + "k"; + final File f = TempFile.createFile(size); + String[] s = null; + if (hasValidHost){ + s = new String[]{"uptemp01.qbox.me", "uptemp02.qbox.me", + "uptemp03.qbox.me", "uptemp04.qbox.me", + "uptemp05.qbox.me", "uptemp06.qbox.me", + "uptemp07.qbox.me", "uptemp08.qbox.me", + "uptemp09.qbox.me", "uptemp10.qbox.me", + "uptemp11.qbox.me", "uptemp12.qbox.me", + "uptemp13.qbox.me", "uptemp14.qbox.me", + "upload-na0.qbox.me", "up-na0.qbox.me"}; + } else { + s = new String[]{"uptemp01.qbox.me", "uptemp02.qbox.me", + "uptemp03.qbox.me", "uptemp04.qbox.me", + "uptemp05.qbox.me", "uptemp06.qbox.me", + "uptemp07.qbox.me", "uptemp08.qbox.me", + "uptemp09.qbox.me", "uptemp10.qbox.me", + "uptemp11.qbox.me", "uptemp12.qbox.me", + "uptemp13.qbox.me", "uptemp14.qbox.me"}; + } + + Zone z = new FixedZone(s); + Configuration c = new Configuration.Builder() + .zone(z).useHttps(true).useConcurrentResumeUpload(false) + .build(); + UploadManager uploadManager = new UploadManager(c); + final UploadOptions options = new UploadOptions(null, null, true, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + LogUtil.i(("progress:" + percent)); + } + }, null); + uploadManager.put(f, expectKey, TestConfig.token_na0, new UpCompletionHandler() { + + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + + if (rinfo.isOK() && rinfo.reqId.length() > 0 + && expectKey.equals(k)){ + + completeHandler.complete(true); +// try { +// String etag_file = Etag.file(f); +// String etag_server = response.getString("hash"); +// if (etag_file.equals(etag_server)){ +// completeHandler.complete(true); +// } else { +// completeHandler.complete(false); +// } +// } catch (IOException ignored) { +// } catch (JSONException ignored) { +// } + } else { + completeHandler.complete(false); + } + + waitCondition.shouldWait = false; + } + }, options); + + wait(waitCondition, 60); + } + + private static class TestParam{ + int count = 100; + int successCount = 0; + int completeCount = 0; + } + + private interface CompleteHandler{ + void complete(boolean isSuccess); + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/SyncFormUploadTest.java b/library/src/androidTest/java/com/qiniu/android/storage/SyncFormUploadTest.java new file mode 100644 index 000000000..b2c3a75c5 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/SyncFormUploadTest.java @@ -0,0 +1,202 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TempFile; +import com.qiniu.android.TestConfig; +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.common.Zone; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.Etag; + +import junit.framework.Assert; + +import org.json.JSONObject; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +@RunWith(AndroidJUnit4.class) +public class SyncFormUploadTest extends BaseTest { + private UploadManager uploadManager; + private volatile String key; + private volatile ResponseInfo info; + private volatile JSONObject resp; + + @Before + public void setUp() { + uploadManager = new UploadManager(); + } + + @Test + public void testHello() { + final String expectKey = "你好-testHello;\"\r\n\r\n\r\n"; + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + byte[] b = "hello".getBytes(); + info = uploadManager.syncPut(b, expectKey, TestConfig.commonToken, opt); + resp = info.response; + + Assert.assertTrue(info.toString(), info.isOK()); + Assert.assertNotNull(info.reqId); + Assert.assertNotNull(resp); + + String hash = resp.optString("hash"); + Assert.assertEquals(hash, Etag.data(b)); + Assert.assertEquals(expectKey, key = resp.optString("key")); + } + + @Test + public void test0Data(){ + final String expectKey = "你好-test0Data;\"\r\n\r\n\r\n"; + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + + info = uploadManager.syncPut("".getBytes(), expectKey, TestConfig.commonToken, opt); + resp = info.response; + + assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); + assertNull(resp); + } + + @Test + public void testNoKey() { + final String expectKey = null; + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + info = uploadManager.syncPut("hello".getBytes(), expectKey, TestConfig.commonToken, opt); + + resp = info.response; + key = resp.optString("key"); + Assert.assertTrue(info.toString(), info.isOK()); + + Assert.assertNotNull(info.reqId); + Assert.assertNotNull(resp); + Assert.assertEquals("Fqr0xh3cxeii2r7eDztILNmuqUNN", resp.optString("key", "")); + } + + @Test + public void testInvalidtoken_z0() { + final String expectKey = "你好-testInvalidtoken_z0"; + info = uploadManager.syncPut("hello".getBytes(), expectKey, "invalid", null); + + resp = info.response; + Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, info.statusCode); + assertNull(resp); + } + + @Test + public void testNoData() { + final String expectKey = "你好-testNoData"; + + info = uploadManager.syncPut((byte[]) null, expectKey, "invalid", null); + + resp = info.response; + Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, + info.statusCode); + Assert.assertNull(resp); + } + + @Test + public void testNotoken_z0() { + final String expectKey = "你好-testNotoken_z0"; + info = uploadManager.syncPut(new byte[1], expectKey, null, null); + + resp = info.response; + Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, info.statusCode); + Assert.assertNull(resp); + } + + @Test + public void testEmptytoken_z0() { + final String expectKey = "你好-testEmptytoken_z0"; + info = uploadManager.syncPut(new byte[1], expectKey, "", null); + + resp = info.response; + Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, + info.statusCode); + Assert.assertNull(resp); + } + + @Test + public void testFile() throws Throwable { + final String expectKey = "世/界-testFile"; + final File f = TempFile.createFile(5*1024); + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + info = uploadManager.syncPut(f, expectKey, TestConfig.commonToken, opt); + + resp = info.response; + key = resp.optString("key"); + assertEquals(info.toString(), expectKey, key); + Assert.assertTrue(info.toString(), info.isOK()); + + //上传策略含空格 \"fname\":\" $(fname) \" +// assertEquals(f.getName(), resp.optString("fname", "res doesn't include the FNAME").trim()); + assertNotNull(info.reqId); + assertNotNull(resp); +// String hash = resp.getString("hash"); +// assertEquals(hash, Etag.file(f)); + TempFile.remove(f); + } + + @Test + public void test0File() throws Throwable { + final String expectKey = "世/界-test0File"; + final File f = TempFile.createFile(0); + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + info = uploadManager.syncPut(f, expectKey, TestConfig.commonToken, opt); + + resp = info.response; + Assert.assertEquals(f.toString(), 0, f.length()); + Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); + Assert.assertNull(resp); + Assert.assertFalse(info.toString(), info.isOK()); + Assert.assertEquals(info.toString(), "", info.reqId); + TempFile.remove(f); + } + + @Test + public void test0byte() { + info = uploadManager.syncPut(new byte[0], null, TestConfig.commonToken, null); + Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); + + info = uploadManager.syncPut("", null, TestConfig.commonToken, null); + Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); + } + + + @Test + public void testHttps() { + final String expectKey = "你好-testHttps;\"\r\n\r\n\r\n"; + Map params = new HashMap(); + params.put("x:foo", "fooval"); + final UploadOptions opt = new UploadOptions(params, null, true, null, null); + String[] s = new String[]{"up-na0.qbox.me"}; + Zone z = new FixedZone(s); + Configuration c = new Configuration.Builder() + .zone(z) + .useHttps(true) + .build(); + UploadManager uploadManager2 = new UploadManager(c); + info = uploadManager2.syncPut("hello".getBytes(), expectKey, TestConfig.commonToken, opt); + + resp = info.response; + key = resp.optString("key"); + Assert.assertEquals(info.toString(), expectKey, key); + Assert.assertTrue(info.toString(), info.isOK()); + Assert.assertNotNull(info.reqId); + Assert.assertNotNull(resp); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/TestFileRecorder.java b/library/src/androidTest/java/com/qiniu/android/storage/TestFileRecorder.java new file mode 100644 index 000000000..03c0581d9 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/TestFileRecorder.java @@ -0,0 +1,239 @@ +package com.qiniu.android.storage; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TempFile; +import com.qiniu.android.TestConfig; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.LogUtil; + +import org.json.JSONObject; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.security.MessageDigest; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +@RunWith(AndroidJUnit4.class) +public class TestFileRecorder extends BaseTest { + private volatile boolean cancelled; + private volatile boolean failed; + private UploadManager uploadManager; + private Configuration config; + private volatile String key; + private volatile ResponseInfo info; + private volatile JSONObject resp; + private volatile UploadOptions options; + + // copy from FileRecorder. + private static String hash(String base) { + try { + MessageDigest digest = MessageDigest.getInstance("SHA-1"); + byte[] hash = digest.digest(base.getBytes()); + StringBuffer hexString = new StringBuffer(); + + for (int i = 0; i < hash.length; i++) { + hexString.append(Integer.toString((hash[i] & 0xff) + 0x100, 16).substring(1)); + } + return hexString.toString(); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + @Override @Before + public void setUp() throws Exception { + File f = File.createTempFile("qiniutest", "b"); + String folder = f.getParent(); + FileRecorder fr = new FileRecorder(folder); + config = new Configuration.Builder().connectTimeout(15000)/*.recorder(fr)*/.build(); + uploadManager = new UploadManager(config); + } + + private void template(final int size, final double pos) throws Throwable { + + info = null; + + final File tempFile = TempFile.createFile(size); + final String expectKey = "rc=" + size + "k"; + cancelled = false; + failed = false; + Map params = new HashMap(); + params.put("x:a", "test"); + params.put("x:b", "test2"); + options = new UploadOptions(params, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + if (percent >= pos) { + cancelled = true; + } + LogUtil.i("progress " + percent); + } + }, new UpCancellationSignal() { + @Override + public boolean isCancelled() { + return cancelled; + } + }); + + uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + LogUtil.i("Cancel:" + k + rinfo); + key = k; + info = rinfo; + resp = response; + } + }, options); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 600); + + assertEquals(info.toString(), expectKey, key); + assertTrue(info.toString(), info.isCancelled()); + assertNull(resp); + + info = null; + cancelled = false; + options = new UploadOptions(null, null, false, new UpProgressHandler() { + @Override + public void progress(String key, double percent) { + if (percent < pos - config.chunkSize / (size * 1024.0)) { + failed = true; + } + LogUtil.i("continue progress " + percent); + } + }, null); + + + uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { + public void complete(String k, ResponseInfo rinfo, JSONObject response) { + LogUtil.i("Continue" + k + rinfo); + key = k; + info = rinfo; + resp = response; + } + }, options); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + if (info == null) { + return true; + } else { + return false; + } + } + }, 60); + + assertEquals(info.toString(), expectKey, key); + assertTrue(info.toString(), info.isOK()); + assertNotNull(resp); + +// String hash = resp.getString("hash"); +// assertEquals(hash, Etag.file(tempFile)); + + TempFile.remove(tempFile); + } + + @Test + public void test_4M1K() throws Throwable { + template(4 * 1024 + 1, 0.5); + + } + + @Test + public void test5M() throws Throwable { + template(5 * 1024, 0.51); + } + + @Test + public void test_5M1K() throws Throwable { + template(5 * 1024 + 1, 0.5); + + } + + @Test + public void test8M() throws Throwable { + template(8 * 1024, 0.51); + } + + @Test + public void test_8M1K() throws Throwable { + template(8 * 1024 + 1, 0.5); + + } + + @Test + public void test10M() throws Throwable { + template(10 * 1024, 0.51); + } + + @Test + public void test_10M1K() throws Throwable { + template(10 * 1024 + 1, 0.5); + + } + + @Test + public void testLastModify() throws IOException { + File f = File.createTempFile("qiniutest", "b"); + String folder = f.getParent(); + FileRecorder fr = new FileRecorder(folder); + + String key = "test_profile_"; + byte[] data = new byte[3]; + data[0] = 'a'; + data[1] = '8'; + data[2] = 'b'; + + fr.set(key, data); + byte[] data2 = fr.get(key); + + File recorderFile = new File(folder, hash(key)); + + long m1 = recorderFile.lastModified(); + + assertEquals(3, data2.length); + assertEquals('8', data2[1]); + + recorderFile.setLastModified(new Date().getTime() - 1000 * 3600 * 48 + 2300); + data2 = fr.get(key); + assertEquals(3, data2.length); + assertEquals('8', data2[1]); + + // 让记录文件过期，两天 + recorderFile.setLastModified(new Date().getTime() - 1000 * 3600 * 48 - 2300); + + long m2 = recorderFile.lastModified(); + + // 过期后，记录数据作废 + byte[] data3 = fr.get(key); + + assertNull(data3); + assertTrue(m1 - m2 > 1000 * 3600 * 48 && m1 - m2 < 1000 * 3600 * 48 + 5500); + + try { + Thread.sleep(2300); + } catch (InterruptedException e) { + e.printStackTrace(); + } + fr.set(key, data); + long m4 = recorderFile.lastModified(); + assertTrue(m4 > m1); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/TokenTest.java b/library/src/androidTest/java/com/qiniu/android/storage/TokenTest.java new file mode 100644 index 000000000..77f3356c3 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/TokenTest.java @@ -0,0 +1,51 @@ +package com.qiniu.android.storage; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertTrue; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Date; + +/** + * Created by bailong on 15/6/1. + */ +@RunWith(AndroidJUnit4.class) +public class TokenTest { + + @Test + public void testRight() { + + UpToken t = UpToken.parse(TestConfig.commonToken); + + assertTrue(!UpToken.isInvalid(t)); + assertTrue("token isValidForDuration error", t.isValidForDuration(5*60)); + assertTrue("token isValidBeforeDate error", t.isValidBeforeDate(new Date())); + assertTrue(t.toString() != null); + assertNotSame(t, null); + } + + public void testEmpty() { + UpToken t = UpToken.parse(null); + assertEquals(t, null); + + t = UpToken.parse(""); + assertEquals(t, null); + + t = UpToken.parse("1:2:3"); + assertEquals(t, null); + } + + @Test + public void testReturnUrl() { + UpToken t = UpToken.parse("QWYn5TFQsLLU1pL5MFEmX3s5DmHdUThav9WyOWOm:1jLiztn4plVyeB8Hie1ryO5z9uo=:eyJzY29wZSI6InB5c2RrIiwiZGVhZGxpbmUiOjE0MzM0ODM5MzYsInJldHVyblVybCI6Imh0dHA6Ly8xMjcuMC4wLjEvIn0="); + assertTrue(t.hasReturnUrl()); + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java new file mode 100644 index 000000000..b699a0301 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java @@ -0,0 +1,277 @@ +package com.qiniu.android.storage; + +import android.net.Uri; +import android.util.Log; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TestConfig; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.Etag; +import com.qiniu.android.utils.LogUtil; + +import org.json.JSONObject; +import org.junit.Before; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.RandomAccessFile; + +//@RunWith(AndroidJUnit4.class) +public class UploadBaseTest extends BaseTest { + + @Override @Before + public void setUp() throws Exception { + LogUtil.enableLog(true); + LogUtil.setLogLevel(Log.VERBOSE); + } + + protected UploadOptions defaultOptions = new UploadOptions(null, null, true, new UpProgressBytesHandler() { + @Override + public void progress(String key, long uploadBytes, long totalBytes) { + double percent = 0; + if (totalBytes > 0) { + percent = (double) uploadBytes / (double) totalBytes; + } + LogUtil.d("== upload key:" + (key == null ? "" : key) + " uploadBytes:" + uploadBytes + " totalBytes:" + totalBytes + " percent:" + percent); + } + + @Override + public void progress(String key, double percent) { + LogUtil.d("== upload key:" + (key == null ? "" : key) + " progress:" + percent); + } + }, null); + + protected boolean verifyUploadKey(String upKey, String responseKey) { + LogUtil.d("== upKey:" + (upKey != null ? upKey : "") + + " responseKey:" + (responseKey != null ? responseKey : "")); + if (upKey == null) { + return responseKey == null; + } + if (responseKey == null) { + return false; + } + return upKey.equals(responseKey); + } + + protected void uploadFileAndAssertSuccessResult(File file, + String key, + Configuration configuration, + UploadOptions options) { + uploadFileAndAssertResult(ResponseInfo.RequestSuccess, file, key, configuration, options); + } + + protected void uploadFileAndAssertSuccessResult(UploadInfo file, + String key, + Configuration configuration, + UploadOptions options) { + uploadFileAndAssertResult(ResponseInfo.RequestSuccess, file, key, configuration, options); + } + + protected void uploadFileAndAssertResult(int statusCode, + File file, + String key, + Configuration configuration, + UploadOptions options) { + + uploadFileAndAssertResult(statusCode, file, TestConfig.token_na0, key, configuration, options); + } + + protected void uploadFileAndAssertResult(int statusCode, + UploadInfo file, + String key, + Configuration configuration, + UploadOptions options) { + + uploadFileAndAssertResult(statusCode, file, TestConfig.token_na0, key, configuration, options); + } + + protected void uploadFileAndAssertResult(int statusCode, + File file, + String token, + String key, + Configuration configuration, + UploadOptions options) { + + UploadInfo fileInfo = new UploadInfo<>(file); + fileInfo.configWithFile(file); + uploadFileAndAssertResult(statusCode, fileInfo, token, key, configuration, options); + + Uri uri = Uri.fromFile(file); + UploadInfo uriInfo = new UploadInfo<>(uri); + uriInfo.configWithFile(file); + uploadFileAndAssertResult(statusCode, uriInfo, token, key, configuration, options); + + InputStream stream = null; + try { + stream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + UploadInfo streamInfo = new UploadInfo<>(stream); + streamInfo.configWithFile(file); + uploadFileAndAssertResult(statusCode, streamInfo, token, key, configuration, options); + if (stream != null) { + try { + stream.close(); + } catch (IOException e) { + } + } + + try { + stream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + streamInfo = new UploadInfo<>(stream); + streamInfo.configWithFile(file); + streamInfo.size = -1; + uploadFileAndAssertResult(statusCode, streamInfo, token, key, configuration, options); + if (stream != null) { + try { + stream.close(); + } catch (IOException e) { + } + } + + if (file.length() < 4 * 1024 * 1024) { + byte[] data = getDataFromFile(file); + UploadInfo dataInfo = new UploadInfo<>(data); + dataInfo.configWithFile(file); + uploadFileAndAssertResult(statusCode, dataInfo, token, key, configuration, options); + } + } + + protected void uploadFileAndAssertResult(int statusCode, + UploadInfo file, + String token, + String key, + Configuration configuration, + UploadOptions options) { + + final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); + upload(file, token, key, configuration, options, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + completeInfo.responseInfo = info; + completeInfo.key = key; + } + }); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return completeInfo.responseInfo == null; + } + }, 10 * 60); + + LogUtil.d("=== upload file type:" + file.type() + " response key:" + (key != null ? key : "") + " response:" + completeInfo.responseInfo); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.statusCode == statusCode); + assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); + + // 成功验证 etag + if (statusCode == ResponseInfo.RequestSuccess) { + String etag = file.etag; + String serverEtag = null; + try { + serverEtag = completeInfo.responseInfo.response.getString("hash"); + } catch (Exception e) { + e.printStackTrace(); + } + LogUtil.d("=== upload etag:" + etag + " response etag:" + serverEtag); + assertEquals("file:" + etag + " server etag:" + serverEtag, etag, serverEtag); + } + } + + protected void upload(UploadInfo file, + String key, + Configuration configuration, + UploadOptions options, + UpCompletionHandler completionHandler) { + + upload(file, TestConfig.token_na0, key, configuration, options, completionHandler); + } + + protected void upload(UploadInfo file, + String token, + String key, + Configuration configuration, + UploadOptions options, + UpCompletionHandler completionHandler) { + if (options == null) { + options = defaultOptions; + } + UploadManager manager = new UploadManager(configuration); + if (file.info instanceof File) { + manager.put((File) file.info, key, token, completionHandler, options); + } else if (file.info instanceof Uri) { + manager.put((Uri) file.info, getContext().getContentResolver(), key, token, completionHandler, options); + } else if (file.info instanceof InputStream) { + manager.put((InputStream) file.info, null, file.size, file.fileName, key, token, completionHandler, options); + } else if (file.info instanceof byte[]) { + manager.put((byte[]) file.info, key, token, completionHandler, options); + } else { + completionHandler.complete(key, ResponseInfo.fileError(new Exception("test case file type error")), null); + } + } + + protected byte[] getDataFromFile(File file) { + byte[] bytes = new byte[(int) file.length()]; + try { + RandomAccessFile accessFile = new RandomAccessFile(file, "r"); + accessFile.readFully(bytes); + } catch (Exception e) { + bytes = null; + } + return bytes; + } + + protected static class UploadInfo { + protected final T info; + protected String fileName; + protected long size = -1; + protected String etag; + protected String md5; + + public UploadInfo(T info) { + this.info = info; + } + + public void configWithFile(File file) { + fileName = file.getName(); + size = file.length(); + try { + etag = Etag.file(file); + } catch (Exception ignore) { + } + + try { + etag = Etag.file(file); + } catch (Exception ignore) { + } + } + + public String type() { + if (info instanceof File) { + return "file"; + } else if (info instanceof Uri) { + return "uri"; + } else if (info instanceof InputStream) { + return "stream"; + } else if (info instanceof byte[]) { + return "byte_array"; + } else { + return "none"; + } + } + } + + protected static class UploadCompleteInfo { + String key; + ResponseInfo responseInfo; + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java new file mode 100644 index 000000000..2c6102a81 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java @@ -0,0 +1,361 @@ +package com.qiniu.android.storage; + + +import android.net.Uri; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.common.FixedZone; +import com.qiniu.android.common.ZoneInfo; +import com.qiniu.android.common.ZonesInfo; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.LogUtil; +import com.qiniu.android.utils.Utils; + +import org.json.JSONObject; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; + +//@RunWith(AndroidJUnit4.class) +public class UploadFlowTest extends UploadBaseTest { + + protected void cancelTest(long cancelPosition, + File file, + String key, + Configuration configuration, + UploadOptions options) { + cancelPosition *= 1024; + + LogUtil.d("======== progress File cancel ============================================"); + UploadInfo fileInfo = new UploadInfo<>(file); + fileInfo.configWithFile(file); + cancelTest(cancelPosition, fileInfo, key, configuration, options); + + Uri uri = Uri.fromFile(file); + UploadInfo uriInfo = new UploadInfo<>(uri); + uriInfo.configWithFile(file); + cancelTest(cancelPosition, uriInfo, key, configuration, options); + + LogUtil.d("======== progress InputStream with size cancel ==========================="); + InputStream stream = null; + try { + stream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + UploadInfo streamInfo = new UploadInfo<>(stream); + streamInfo.configWithFile(file); + cancelTest(cancelPosition, streamInfo, key, configuration, options); + + LogUtil.d("======== progress InputStream without size cancel ========================="); + stream = null; + try { + stream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + streamInfo = new UploadInfo<>(stream); + streamInfo.configWithFile(file); + streamInfo.size = -1; + cancelTest(cancelPosition, streamInfo, key, configuration, options); + + LogUtil.d("======== progress data cancel ============================================="); + if (file.length() < 4 * 1024 * 1024) { + byte[] data = getDataFromFile(file); + UploadInfo dataInfo = new UploadInfo<>(data); + dataInfo.configWithFile(file); + cancelTest(cancelPosition, dataInfo, key, configuration, options); + } + } + + private void cancelTest(final long cancelPosition, + UploadInfo file, + String key, + Configuration configuration, + UploadOptions options) { + + if (options == null) { + options = defaultOptions; + } + + final UploadOptions optionsReal = options; + final Flags flags = new Flags(); + UploadOptions cancelOptions = new UploadOptions(optionsReal.params, optionsReal.mimeType, optionsReal.checkCrc, new UpProgressBytesHandler() { + @Override + public void progress(String key, long uploadBytes, long totalBytes) { + if (cancelPosition < uploadBytes) { + flags.shouldCancel = true; + } + if (optionsReal.progressHandler instanceof UpProgressBytesHandler) { + ((UpProgressBytesHandler)optionsReal.progressHandler).progress(key, uploadBytes, totalBytes); + } + } + + @Override + public void progress(String key, double percent) { + } + }, new UpCancellationSignal() { + @Override + public boolean isCancelled() { + + return flags.shouldCancel; + } + }, options.netReadyHandler); + + final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); + upload(file, key, configuration, cancelOptions, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + completeInfo.key = key; + completeInfo.responseInfo = info; + } + }); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return completeInfo.responseInfo == null; + } + }, 5 * 60); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.isCancelled()); + assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); + } + + protected void reuploadUploadTest(long resumePosition, + File file, + String key, + Configuration configuration, + UploadOptions options) { + + resumePosition *= 1024; + + LogUtil.d("======== progress File ReUpload =============================================="); + UploadInfo fileInfo = new UploadInfo<>(file); + fileInfo.configWithFile(file); + reuploadUploadTest(resumePosition, fileInfo, fileInfo, key, configuration, options); + + LogUtil.d("======== progress Uri ReUpload =============================================="); + Uri uri = Uri.fromFile(file); + UploadInfo uriInfo = new UploadInfo<>(uri); + uriInfo.configWithFile(file); + reuploadUploadTest(resumePosition, uriInfo, uriInfo, key, configuration, options); + + LogUtil.d("======== progress InputStream with size ReUpload ============================="); + InputStream firstStream = null; + try { + firstStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + UploadInfo firstStreamInfo = new UploadInfo<>(firstStream); + firstStreamInfo.configWithFile(file); + + InputStream secondStream = null; + try { + secondStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + UploadInfo secondStreamInfo = new UploadInfo<>(secondStream); + secondStreamInfo.configWithFile(file); + + reuploadUploadTest(resumePosition, firstStreamInfo, secondStreamInfo, key, configuration, options); + try { + firstStream.close(); + secondStream.close(); + } catch (IOException e) { + } + + LogUtil.d("======== progress InputStream without size ReUpload =========================="); + firstStream = null; + try { + firstStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + firstStreamInfo = new UploadInfo<>(firstStream); + firstStreamInfo.configWithFile(file); + firstStreamInfo.size = -1; + + secondStream = null; + try { + secondStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + } + secondStreamInfo = new UploadInfo<>(secondStream); + secondStreamInfo.configWithFile(file); + secondStreamInfo.size = -1; + + reuploadUploadTest(resumePosition, firstStreamInfo, secondStreamInfo, key, configuration, options); + try { + firstStream.close(); + secondStream.close(); + } catch (IOException e) { + } + } + + private void reuploadUploadTest(final long resumePosition, + final UploadInfo firstFile, + final UploadInfo secondFile, + String key, + final Configuration configuration, + UploadOptions options) { + + FileRecorder fileRecorder = null; + try { + fileRecorder = new FileRecorder(Utils.sdkDirectory() + "/Test"); + } catch (IOException e) { + e.printStackTrace(); + } + + final Configuration reuploadConfiguration = new Configuration.Builder() + .chunkSize(configuration.chunkSize) + .putThreshold(configuration.putThreshold) + .retryMax(configuration.retryMax) + .connectTimeout(configuration.connectTimeout) + .responseTimeout(configuration.responseTimeout) + .retryInterval(configuration.retryInterval) + .recorder(fileRecorder, null) + .proxy(configuration.proxy) + .urlConverter(configuration.urlConverter) + .useHttps(configuration.useHttps) + .allowBackupHost(configuration.allowBackupHost) + .useConcurrentResumeUpload(configuration.useConcurrentResumeUpload) + .resumeUploadVersion(configuration.resumeUploadVersion) + .concurrentTaskCount(configuration.concurrentTaskCount) + .zone(configuration.zone) + .build(); + + + if (options == null) { + options = defaultOptions; + } + final UploadOptions optionsReal = options; + + cancelTest(resumePosition, firstFile, key, reuploadConfiguration, optionsReal); + + LogUtil.d("progress ReUpload ===================================================="); + + final Flags flags = new Flags(); + UploadOptions reuploadOptions = new UploadOptions(optionsReal.params, optionsReal.mimeType, optionsReal.checkCrc, new UpProgressBytesHandler() { + @Override + public void progress(String key, double percent) { + } + + @Override + public void progress(String key, long uploadBytes, long totalBytes) { + if (!flags.flags) { + flags.flags = true; + if (uploadBytes <= resumePosition && uploadBytes > 0) { + flags.isSuccess = true; + } + } + + if (optionsReal.progressHandler != null && optionsReal.progressHandler instanceof UpProgressBytesHandler) { + ((UpProgressBytesHandler)optionsReal.progressHandler).progress(key, uploadBytes, totalBytes); + } + } + }, null, options.netReadyHandler); + + final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); + upload(secondFile, key, reuploadConfiguration, reuploadOptions, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + completeInfo.key = key; + completeInfo.responseInfo = info; + } + }); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return completeInfo.responseInfo == null; + } + }, 10* 60); + assertTrue(completeInfo.responseInfo.toString(), flags.isSuccess); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.isOK()); + assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); + } + + protected void switchRegionTestWithFile(File file, + String key, + Configuration configuration, + UploadOptions options) { + + UploadInfo fileInfo = new UploadInfo<>(file); + fileInfo.configWithFile(file); + switchRegionTestWithFile(fileInfo, key, configuration, options); + + Uri uri = Uri.fromFile(file); + UploadInfo uriInfo = new UploadInfo<>(uri); + uriInfo.configWithFile(file); + switchRegionTestWithFile(uriInfo, key, configuration, options); + + if (file.length() < 4 * 1024 * 1024) { + byte[] data = getDataFromFile(file); + UploadInfo dataInfo = new UploadInfo<>(data); + dataInfo.configWithFile(file); + switchRegionTestWithFile(dataInfo, key, configuration, options); + } + } + + private void switchRegionTestWithFile(UploadInfo file, + String key, + Configuration configuration, + UploadOptions options) { + if (configuration == null) { + configuration = new Configuration.Builder().build(); + } + Configuration configurationReal = configuration; + + ArrayList hostArray0 = new ArrayList<>(); + hostArray0.add("mock1.up.qiniup.com"); + hostArray0.add("mock2.up.qiniup.com"); + ZoneInfo zoneInfo0 = ZoneInfo.buildInfo(hostArray0, null, null); + + ArrayList hostArray1 = new ArrayList<>(); + hostArray1.add("upload.qiniup.com"); + hostArray1.add("up.qiniup.com"); + ZoneInfo zoneInfo1 = ZoneInfo.buildInfo(hostArray1, null, null); + + ArrayList hostArray2 = new ArrayList<>(); + hostArray2.add("upload-na0.qiniup.com"); + hostArray2.add("up-na0.qiniup.com"); + ZoneInfo zoneInfo2 = ZoneInfo.buildInfo(hostArray2, null, null); + + ArrayList zoneInfoArray = new ArrayList<>(); + zoneInfoArray.add(zoneInfo0); + zoneInfoArray.add(zoneInfo1); + zoneInfoArray.add(zoneInfo2); + ZonesInfo zonesInfo = new ZonesInfo(zoneInfoArray); + FixedZone zone = new FixedZone(zonesInfo); + + Configuration switchConfiguration = new Configuration.Builder() + .chunkSize(configurationReal.chunkSize) + .putThreshold(configurationReal.putThreshold) + .retryMax(configurationReal.retryMax) + .connectTimeout(configurationReal.connectTimeout) + .responseTimeout(configurationReal.responseTimeout) + .retryInterval(configurationReal.retryInterval) + .recorder(configurationReal.recorder, configurationReal.keyGen) + .proxy(configurationReal.proxy) + .urlConverter(configurationReal.urlConverter) + .useHttps(configurationReal.useHttps) + .allowBackupHost(configurationReal.allowBackupHost) + .useConcurrentResumeUpload(configurationReal.useConcurrentResumeUpload) + .resumeUploadVersion(configurationReal.resumeUploadVersion) + .concurrentTaskCount(configurationReal.concurrentTaskCount) + .zone(zone) + .build(); + uploadFileAndAssertSuccessResult(file, key, switchConfiguration, options); + } + + protected static class Flags { + boolean flags; + boolean shouldCancel; + boolean isSuccess; + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java new file mode 100644 index 000000000..50d707669 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java @@ -0,0 +1,203 @@ +package com.qiniu.android.storage; + +import android.content.ContentResolver; +import android.content.ContentValues; +import android.net.Uri; +import android.provider.MediaStore; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; +import com.qiniu.android.TempFile; +import com.qiniu.android.TestConfig; +import com.qiniu.android.http.ResponseInfo; +import com.qiniu.android.utils.ContextGetter; +import com.qiniu.android.utils.Etag; +import com.qiniu.android.utils.LogUtil; + +import junit.framework.Assert; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +@RunWith(AndroidJUnit4.class) +public class UriTest extends BaseTest { + + private static boolean[][] testConfigList = { + {true, true, true}, + {true, true, false}, + {true, false, true}, + {true, false, false}, + + {false, true, true}, + {false, true, false}, + {false, false, true}, + {false, false, false}, + }; + + private void notestUpload() { + int MB = 1024; + int[] sizeList = {512, MB, 4*MB, 5*MB, 8*MB, 10*MB, 20*MB}; + for (int size : sizeList) { + String fileName = size + "KB" + ".mp4"; + + File file = createFile(size); + Uri uri = null; + try { + uri = writeFileToDownload(file, fileName); + } catch (FileNotFoundException e) { + e.printStackTrace(); + Assert.fail(e.getMessage()); + return; + } + + String etag = null; + try { + etag = Etag.file(file); + } catch (IOException e) { + e.printStackTrace(); + } + for (boolean[] config : testConfigList) { + testUpload(uri, fileName, etag, config[0], config[1], config[2]); + } + removeUri(uri); + } + } + + + @Test + public void testUpload() { + String uriString = "content://media/external/images/media/12045"; + Uri uri = Uri.parse(uriString); + testUpload(uri, "uri_test", "AAAA", true, false, false); + } + + private void testUpload(Uri uri, String fileName, String etag, boolean isHttps, boolean isResumableV1, boolean isConcurrent) { + + assertNotNull("Uri write file error:" + fileName, uri); + + Configuration configuration = new Configuration.Builder() + .resumeUploadVersion(isResumableV1 ? Configuration.RESUME_UPLOAD_VERSION_V1 : Configuration.RESUME_UPLOAD_VERSION_V2) + .chunkSize(isResumableV1 ? 1024*1024*2 : 1024*1024*4) + .useConcurrentResumeUpload(isConcurrent) + .useHttps(isHttps) + .build(); + + UploadManager uploadManager = new UploadManager(configuration); + + String key = "uri_upload_"; + key += isHttps ? "https_" : "http_"; + key += isResumableV1 ? "v1_" : "v2_"; + key += isConcurrent ? "serial_" : "concurrent_"; + key += fileName; + final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); + uploadManager.put(uri, null, key, TestConfig.token_na0, new UpCompletionHandler() { + @Override + public void complete(String key, ResponseInfo info, JSONObject response) { + completeInfo.key = key; + completeInfo.responseInfo = info; + } + }, null); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return completeInfo.responseInfo == null; + } + }, 10 * 60); + + LogUtil.d("=== upload response key:" + (key != null ? key : "") + " response:" + completeInfo.responseInfo); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); + assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.statusCode == ResponseInfo.RequestSuccess); + assertTrue(completeInfo.responseInfo.toString(), key.equals(completeInfo.key)); + + String serverEtag = null; + try { + serverEtag = completeInfo.responseInfo.response.getString("hash"); + } catch (JSONException e) { + e.printStackTrace(); + } + System.out.println(" etag:" + etag); + System.out.println("serverEtag:" + serverEtag); + assertNotNull("key:" + key, serverEtag); + assertEquals("key:" + key, etag, serverEtag); + } + + private File createFile(int size) { + File file = null; + try { + file = TempFile.createFile(size); + } catch (IOException e) { + e.printStackTrace(); + } + return file; + } + + private Uri writeFileToDownload(File file, String fileName) throws FileNotFoundException { + + InputStream inputStream = null; + try { + inputStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + e.printStackTrace(); + throw e; + } + + ContentResolver resolver = ContextGetter.applicationContext().getContentResolver(); + + ContentValues contentValues = new ContentValues(); + contentValues.put(MediaStore.Video.Media.DISPLAY_NAME, fileName); + Uri imageUri = null; + try { + imageUri = resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues); + } catch (Exception e) { + e.printStackTrace(); + throw e; + } + + if (imageUri != null) { + // 若生成了uri，则表示该文件添加成功 + // 使用流将内容写入该uri中即可 + OutputStream outputStream = null; + try { + outputStream = resolver.openOutputStream(imageUri); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + if (outputStream != null) { + try { + byte[] buf = new byte[1024]; + int len; + while ((len = inputStream.read(buf)) > 0) { + outputStream.write(buf, 0, len); + } + outputStream.close(); + inputStream.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + return imageUri; + } + + private void removeUri(Uri uri) { + ContentResolver resolver = ContextGetter.applicationContext().getContentResolver(); + resolver.delete(uri, null, null); + } + + protected static class UploadCompleteInfo { + String key; + ResponseInfo responseInfo; + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/storage/serverConfig/ServerConfigTest.java b/library/src/androidTest/java/com/qiniu/android/storage/serverConfig/ServerConfigTest.java new file mode 100644 index 000000000..0ec8c67ee --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/storage/serverConfig/ServerConfigTest.java @@ -0,0 +1,73 @@ +package com.qiniu.android.storage.serverConfig; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TestConfig; +import com.qiniu.android.BaseTest; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class ServerConfigTest extends BaseTest { + + @Test + public void testMonitor() { + ServerConfigMonitor.removeConfigCache(); + ServerConfigMonitor.startMonitor(); + ServerConfigMonitor.setToken(TestConfig.token_na0); + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return true; + } + }, 30); + } + + @Test + public void testServerConfigModel() { + String serverConfigJsonString = "{\"region\":{\"clear_id\":10,\"clear_cache\":true},\"dns\":{\"enabled\":true,\"clear_id\":10,\"clear_cache\":true,\"doh\":{\"enabled\":true,\"ipv4\":{\"override_default\":true,\"urls\":[\"https://223.5.5.5/dns-query\"]},\"ipv6\":{\"override_default\":true,\"urls\":[\"https://FFAE::EEEE/dns-query\"]}},\"udp\":{\"enabled\":true,\"ipv4\":{\"ips\":[\"223.5.5.5\",\"1.1.1.1\"],\"override_default\":true},\"ipv6\":{\"ips\":[\"FFAE::EEEE\"],\"override_default\":true}}},\"ttl\":86400}"; + try { + JSONObject jsonObject = new JSONObject(serverConfigJsonString); + ServerConfig serverConfig = new ServerConfig(jsonObject); + assertTrue("server config ttl was err", serverConfig.isValid()); + assertTrue("server config dns was null", serverConfig.getDnsConfig() != null); + assertTrue("server config dns enable was null", serverConfig.getDnsConfig().getEnable() != null); + assertTrue("server config dns clear id was null", serverConfig.getDnsConfig().getClearId() > 0); + assertTrue("server config dns udp was null", serverConfig.getDnsConfig().getUdpDnsConfig() != null); + assertTrue("server config dns udp enable was null", serverConfig.getDnsConfig().getUdpDnsConfig().getEnable() != null); + assertTrue("server config dns udp ipv4 server was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server() != null); + assertTrue("server config dns udp ipv4 server isOverride was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server().getIsOverride()); + assertTrue("server config dns udp ipv4 server servers was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server().getServers() != null); + assertTrue("server config dns udp ipv6 server was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server() != null); + assertTrue("server config dns udp ipv6 server isOverride was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server().getIsOverride()); + assertTrue("server config dns udp ipv6 server servers was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server().getServers() != null); + assertTrue("server config dns doh was null", serverConfig.getDnsConfig().getDohDnsConfig() != null); + assertTrue("server config dns doh enable was null", serverConfig.getDnsConfig().getDohDnsConfig().getEnable() != null); + assertTrue("server config dns doh ipv4 server was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server() != null); + assertTrue("server config dns doh ipv4 server isOverride was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server().getIsOverride()); + assertTrue("server config dns doh ipv4 server servers was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server().getServers() != null); + assertTrue("server config dns doh ipv6 server was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server() != null); + assertTrue("server config dns doh ipv6 server isOverride was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server().getIsOverride()); + assertTrue("server config dns doh ipv6 server servers was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server().getServers() != null); + assertTrue("server config region was null", serverConfig.getRegionConfig() != null); + assertTrue("server config region clear id was null", serverConfig.getRegionConfig().getClearId() > 0); + } catch (JSONException e) { + fail("server config exception:" + e); + } + + String serverUserConfigJsonString = "{\"ttl\":86400,\"http3\":{\"enabled\":true},\"network_check\":{\"enabled\":true}}"; + try { + JSONObject jsonObject = new JSONObject(serverUserConfigJsonString); + ServerUserConfig serverUserConfig = new ServerUserConfig(jsonObject); + assertTrue("server user config ttl was error", serverUserConfig.isValid()); + assertTrue("server user config http3 enable was null", serverUserConfig.getHttp3Enable() != null); + assertTrue("server user config network check enable id was null", serverUserConfig.getNetworkCheckEnable()); + } catch (JSONException e) { + fail("server config exception:" + e); + } + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/transaction/TransactionManagerTest.java b/library/src/androidTest/java/com/qiniu/android/transaction/TransactionManagerTest.java index e82a9677b..f4c295a4e 100644 --- a/library/src/androidTest/java/com/qiniu/android/transaction/TransactionManagerTest.java +++ b/library/src/androidTest/java/com/qiniu/android/transaction/TransactionManagerTest.java @@ -1,17 +1,24 @@ package com.qiniu.android.transaction; +import androidx.test.ext.junit.runners.AndroidJUnit4; + import com.qiniu.android.BaseTest; import com.qiniu.android.utils.LogUtil; import com.qiniu.android.utils.Utils; +import org.junit.Test; +import org.junit.runner.RunWith; + import java.lang.reflect.Field; import java.util.Date; /** * Created by yangsen on 2020/6/9 */ +@RunWith(AndroidJUnit4.class) public class TransactionManagerTest extends BaseTest { + @Test public void testTransaction(){ TransactionManager.Transaction normal = new TransactionManager.Transaction("1", 0, new Runnable() { @@ -32,6 +39,7 @@ public void run() { assertNotNull(time); } + @Test public void testTransactionManagerAddAndRemove(){ final int[] executedTransaction = {0}; diff --git a/library/src/androidTest/java/com/qiniu/android/utils/AndroidNetworkTest.java b/library/src/androidTest/java/com/qiniu/android/utils/AndroidNetworkTest.java new file mode 100644 index 000000000..43cc3c1ab --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/AndroidNetworkTest.java @@ -0,0 +1,25 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class AndroidNetworkTest extends BaseTest { + + @Test + public void testHostIP(){ + String ip = AndroidNetwork.getHostIP(); + assertTrue(ip != null); + } + + @Test + public void testNetworkType(){ + String type = AndroidNetwork.networkType(ContextGetter.applicationContext()); + assertTrue(type != null); + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/AsynTest.java b/library/src/androidTest/java/com/qiniu/android/utils/AsynTest.java new file mode 100644 index 000000000..2a9f56dcf --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/AsynTest.java @@ -0,0 +1,151 @@ +package com.qiniu.android.utils; + +import android.os.Looper; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +@RunWith(AndroidJUnit4.class) +public class AsynTest extends BaseTest { + + private class TestParam { + int maxCount; + int completeCount; + int successCount; + } + + @Test + public void testAsyncMainOnMainThread() { + + final TestParam testParam = new TestParam(); + testParam.maxCount = 100; + testParam.completeCount = 0; + testParam.successCount = 0; + for (int i = 0; i < testParam.maxCount; i++) { + final int i_p = i; + AsyncRun.runInMain(new Runnable() { + @Override + public void run() { + + if (Thread.currentThread() == Looper.getMainLooper().getThread()) { + testParam.successCount += 1; + } + + String threadName = Thread.currentThread().getName(); + LogUtil.d("thread name:" + threadName); + + testParam.completeCount += 1; + } + }); + } + + WaitConditional waitConditional = new WaitConditional() { + @Override + public boolean shouldWait() { + if (testParam.completeCount == testParam.maxCount) { + return false; + } else { + return true; + } + } + }; + + wait(waitConditional, 5); + + LogUtil.i(String.format("success count: %d", testParam.successCount)); + assertTrue((testParam.successCount == testParam.maxCount)); + } + + @Test + public void testAsyncMainOnOtherThread() { + + final TestParam testParam = new TestParam(); + testParam.maxCount = 10; + testParam.completeCount = 0; + testParam.successCount = 0; + for (int i = 0; i < testParam.maxCount; i++) { + final int i_p = i; + + new Thread(new Runnable() { + @Override + public void run() { + AsyncRun.runInMain(new Runnable() { + @Override + public void run() { + + if (Thread.currentThread() == Looper.getMainLooper().getThread()) { + testParam.successCount += 1; + } + + String threadName = Thread.currentThread().getName(); + LogUtil.d("thread name:" + threadName); + + testParam.completeCount += 1; + } + }); + } + }).start(); + } + + WaitConditional waitConditional = new WaitConditional() { + @Override + public boolean shouldWait() { + if (testParam.completeCount == testParam.maxCount) { + return false; + } else { + return true; + } + } + }; + + wait(waitConditional, 5); + + LogUtil.i(String.format("success count: %d", testParam.successCount)); + assertTrue((testParam.successCount == testParam.maxCount)); + } + + @Test + public void testAsyncBg() { + final TestParam testParam = new TestParam(); + testParam.maxCount = 100; + testParam.completeCount = 0; + testParam.successCount = 0; + for (int i = 0; i < testParam.maxCount; i++) { + final int i_p = i; + AsyncRun.runInBack(new Runnable() { + @Override + public void run() { + String threadName = Thread.currentThread().getName(); + if (Thread.currentThread() != Looper.getMainLooper().getThread()) { + synchronized (this) { + testParam.successCount += 1; + } + } + synchronized (this) { + testParam.completeCount += 1; + } + } + }); + } + + WaitConditional waitConditional = new WaitConditional() { + @Override + public boolean shouldWait() { + if (testParam.completeCount == testParam.maxCount) { + return false; + } else { + return true; + } + } + }; + + wait(waitConditional, 5); + + LogUtil.i(String.format("success count: %d", testParam.successCount)); + assertTrue("pass", (testParam.successCount == testParam.maxCount)); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/Base64Test.java b/library/src/androidTest/java/com/qiniu/android/utils/Base64Test.java new file mode 100644 index 000000000..25ecdae2a --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/Base64Test.java @@ -0,0 +1,18 @@ +package com.qiniu.android.utils; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; + +import java.io.UnsupportedEncodingException; + + +public class Base64Test extends BaseTest { + + @Test + public void testEncode() throws UnsupportedEncodingException { + String data = "你好/+="; + String result = UrlSafeBase64.encodeToString(data); + assertEquals("5L2g5aW9Lys9", result); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/ContextTest.java b/library/src/androidTest/java/com/qiniu/android/utils/ContextTest.java new file mode 100644 index 000000000..b9f7fab3b --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/ContextTest.java @@ -0,0 +1,20 @@ +package com.qiniu.android.utils; + +import static org.junit.Assert.assertNotNull; + +import android.content.Context; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class ContextTest { + + @Test + public void testEncode() { + Context c = ContextGetter.applicationContext(); + assertNotNull(c); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/CrcTest.java b/library/src/androidTest/java/com/qiniu/android/utils/CrcTest.java new file mode 100644 index 000000000..dcf2ed2aa --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/CrcTest.java @@ -0,0 +1,21 @@ +package com.qiniu.android.utils; + +import static org.junit.Assert.assertEquals; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.utils.Crc32; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class CrcTest { + + @Test + public void testCrc() { + byte[] data = "Hello, World!".getBytes(); + long result = Crc32.bytes(data); + assertEquals(3964322768L, result); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/EtagTest.java b/library/src/androidTest/java/com/qiniu/android/utils/EtagTest.java new file mode 100644 index 000000000..1fa48dda8 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/EtagTest.java @@ -0,0 +1,61 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.TempFile; +import com.qiniu.android.common.Constants; +import com.qiniu.android.storage.Configuration; + +import junit.framework.Assert; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.IOException; +import java.io.UnsupportedEncodingException; + +@RunWith(AndroidJUnit4.class) +public class EtagTest { + + @Test + public void testData() { + String m = Etag.data(new byte[0]); + Assert.assertEquals("Fto5o-5ea0sNMlW_75VgGJCv2AcJ", m); + + try { + String etag = Etag.data("etag".getBytes(Constants.UTF_8)); + Assert.assertEquals("FpLiADEaVoALPkdb8tJEJyRTXoe_", etag); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + } + + @Test + public void testFile() throws IOException { + File f = TempFile.createFile(1024); + Assert.assertEquals("FhHnGzB75K2JC4YOzKDMLEiaeSKm", Etag.file(f)); + TempFile.remove(f); + f = TempFile.createFile(4 * 1024); + Assert.assertEquals("FuPHVcYFMpfuoCTDGF5PCjMY9xxu", Etag.file(f)); + TempFile.remove(f); + f = TempFile.createFile(5 * 1024); + Assert.assertEquals("lkr1cErNyp23IdWan82rufDn3dzT", Etag.file(f)); + TempFile.remove(f); + f = TempFile.createFile(8 * 1024); + Assert.assertEquals("lkRgUHWNADyQ0TRirdqoS7UWFql4", Etag.file(f)); + TempFile.remove(f); + f = TempFile.createFile(9 * 1024); + Assert.assertEquals("lvlmp343GVuq367WF4XTMetchhid", Etag.file(f)); + TempFile.remove(f); + } + + @Test + public void testLongToInt() { + long len = 2323435710l; + int b = (int) ((len + Configuration.BLOCK_SIZE - 1) / Configuration.BLOCK_SIZE); + Assert.assertEquals("不应该溢出", 554, b); + int a = (int) (len + Configuration.BLOCK_SIZE - 1) / Configuration.BLOCK_SIZE; + Assert.assertNotSame("预计会溢出", 554, a); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/GZipTest.java b/library/src/androidTest/java/com/qiniu/android/utils/GZipTest.java new file mode 100644 index 000000000..c36bbacc7 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/GZipTest.java @@ -0,0 +1,59 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Arrays; + +@RunWith(AndroidJUnit4.class) +public class GZipTest extends BaseTest { + + @Test + public void testGZipString(){ + + String string = null; + + byte[] gzip = GZipUtil.gZip(string); + assertTrue(gzip == null); + + string = ""; + gzip = GZipUtil.gZip(string); + assertTrue(Arrays.equals(gzip, string.getBytes())); + + + string = "ABCDEFG"; + gzip = GZipUtil.gZip(string); + + byte[] gUnzip = GZipUtil.gUnzip(gzip); + String stringGUnzip = new String(gUnzip); + + assertTrue(string.equals(stringGUnzip)); + } + + @Test + public void testGZipByte(){ + + byte[] bytes = null; + + byte[] gzip = GZipUtil.gZip(bytes); + assertTrue(gzip == null); + + bytes = new byte[0]; + gzip = GZipUtil.gZip(bytes); + assertTrue(Arrays.equals(bytes, gzip)); + + + String string = "ABCDEFG"; + bytes = string.getBytes(); + gzip = GZipUtil.gZip(bytes); + + byte[] gUnzip = GZipUtil.gUnzip(gzip); + String stringGUnzip = new String(gUnzip); + + assertTrue(string.equals(stringGUnzip)); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/JsonTest.java b/library/src/androidTest/java/com/qiniu/android/utils/JsonTest.java new file mode 100644 index 000000000..5977404f7 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/JsonTest.java @@ -0,0 +1,121 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import junit.framework.Assert; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Created by Simon on 3/3/16. + */ +@RunWith(AndroidJUnit4.class) +public class JsonTest { + + private boolean showContent = false; + + @Test + public void testEmpty() { + JSONObject json = new JSONObject(); + Assert.assertNotNull(json); + Assert.assertEquals("{}", json.toString()); + } + + // e: org.json.JSONException: End of input at character 0 of + @Test + public void testEmpty1() throws JSONException { + String str = ""; + Exception ex = null; + try { + JSONObject json = new JSONObject(str); + } catch (JSONException e) { + ex = e; + } + Assert.assertNotNull(ex); + if (showContent) { + Assert.assertEquals(str, ex.getMessage()); + } + } + + //e: org.json.JSONException: End of input at character 2 of + @Test + public void testEmpty2() throws JSONException { + String str = " "; + Exception ex = null; + try { + JSONObject json = new JSONObject(str); + } catch (JSONException e) { + ex = e; + } + Assert.assertNotNull(ex); + if (showContent) { + Assert.assertEquals(str, ex.getMessage()); + } + } + + @Test + public void testB() throws JSONException { + String str = "{}"; + JSONObject json = new JSONObject(str); + Assert.assertNotNull(json); + if (showContent) { + Assert.assertEquals(str, json.toString()); + } + } + + // e: org.json.JSONException: Value [] of type org.json.JSONArray cannot be converted to JSONObject + @Test + public void testArray() throws JSONException { + String str = "[]"; + Exception ex = null; + try { + JSONObject json = new JSONObject(str);// should JSONArray + } catch (JSONException e) { + ex = e; + } + Assert.assertNotNull(ex); + if (showContent) { + Assert.assertEquals(str, ex.getMessage()); + } + } + + //e: org.json.JSONException: Value null of type org.json.JSONObject$1 cannot be converted to JSONObject + @Test + public void testNull() throws JSONException { + String str = "null"; + Exception ex = null; + try { + JSONObject json = new JSONObject(str); + } catch (JSONException e) { + ex = e; + } + Assert.assertNotNull(ex); + if (showContent) { + Assert.assertEquals(str, ex.getMessage()); + } + } + + @Test + public void testEncodeMap() { + Map m = new HashMap<>(); + m.put("a", 1); + String s = Json.encodeMap(m); + Assert.assertEquals("{\"a\":1}", s); + } + + @Test + public void testEncodeList() { + List l = new ArrayList<>(); + l.add("a"); + String s = Json.encodeList(l); + Assert.assertEquals("[\"a\"]", s); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/ListVectorTest.java b/library/src/androidTest/java/com/qiniu/android/utils/ListVectorTest.java new file mode 100644 index 000000000..9e0645e1e --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/ListVectorTest.java @@ -0,0 +1,84 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import junit.framework.Assert; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.List; + +@RunWith(AndroidJUnit4.class) +public class ListVectorTest extends BaseTest { + + @Test + public void testVectorList() { + + final int count = 1000; + final ListVector v = new ListVector<>(); + + new Thread(new Runnable() { + @Override + public void run() { + while (v.size() < count) { + vectorAdd(v); + } + } + }).start(); + + while (v.size() < count) { + vectorList(v); + } + + Assert.assertTrue("v:" + v, v.size() == count); + } + + @Test + public void testVectorSubList() { + + final int count = 1000; + final ListVector listVector = new ListVector<>(); + + while (listVector.size() < count) { + vectorAdd(listVector); + } + + final ListVector v = listVector.subList(0, count/2); + + new Thread(new Runnable() { + @Override + public void run() { + while (v.size() < count) { + vectorAdd(v); + } + } + }).start(); + + + while (v.size() < count) { + vectorList(v); + } + + Assert.assertTrue("v:" + v, v.size() == count); + } + + private void vectorAdd(List v) { + String e = v.size() + ""; + v.add(e); + System.out.println("add e:" + e); + } + + private void vectorList(ListVector v) { + final int size = v.size(); + v.enumerateObjects(new ListVector.EnumeratorHandler() { + @Override + public boolean enumerate(String s) { + System.out.println("size:" + size + " value:" + s); + return false; + } + }); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/LogUtilsTest.java b/library/src/androidTest/java/com/qiniu/android/utils/LogUtilsTest.java new file mode 100644 index 000000000..20c0fd6f3 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/LogUtilsTest.java @@ -0,0 +1,54 @@ +package com.qiniu.android.utils; + +import android.util.Log; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class LogUtilsTest extends BaseTest { + + @Test + public void testLog() { + + LogUtil.enableLog(true); + LogUtil.setLogLevel(Log.VERBOSE); + + Throwable throwable = new Throwable(); + + assertTrue(validLogCode(LogUtil.v("log"))); + assertTrue(validLogCode(LogUtil.v("v", "log"))); + assertTrue(validLogCode(LogUtil.v("v", "log", null))); + assertTrue(validLogCode(LogUtil.v("v", "log", throwable))); + + assertTrue(validLogCode(LogUtil.d("log"))); + assertTrue(validLogCode(LogUtil.d("v", "log"))); + assertTrue(validLogCode(LogUtil.d("v", "log", null))); + assertTrue(validLogCode(LogUtil.d("v", "log", throwable))); + + assertTrue(validLogCode(LogUtil.i("log"))); + assertTrue(validLogCode(LogUtil.i("v", "log"))); + assertTrue(validLogCode(LogUtil.i("v", "log", null))); + assertTrue(validLogCode(LogUtil.i("v", "log", throwable))); + + assertTrue(validLogCode(LogUtil.w("log"))); + assertTrue(validLogCode(LogUtil.w("v", "log"))); + assertTrue(validLogCode(LogUtil.w("v", "log", null))); + assertTrue(validLogCode(LogUtil.w("v", "log", throwable))); + + assertTrue(validLogCode(LogUtil.e("log"))); + assertTrue(validLogCode(LogUtil.e("v", "log"))); + assertTrue(validLogCode(LogUtil.e("v", "log", null))); + assertTrue(validLogCode(LogUtil.e("v", "log", throwable))); + + LogUtil.enableLog(false); + } + + private boolean validLogCode(int code) { + return !(code == -10000 || code == -10001); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/NetworkTest.java b/library/src/androidTest/java/com/qiniu/android/utils/NetworkTest.java new file mode 100644 index 000000000..e1e21454f --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/NetworkTest.java @@ -0,0 +1,21 @@ +package com.qiniu.android.utils; + +import static org.junit.Assert.assertTrue; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Created by bailong on 16/9/7. + */ +@RunWith(AndroidJUnit4.class) +public class NetworkTest { + + @Test + public void testConnected() { + boolean stat = AndroidNetwork.isNetWorkReady(); + assertTrue(stat); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/SingleFlightTest.java b/library/src/androidTest/java/com/qiniu/android/utils/SingleFlightTest.java new file mode 100644 index 000000000..2a55a8d17 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/SingleFlightTest.java @@ -0,0 +1,197 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class SingleFlightTest extends BaseTest { + + private static final int RetryCount = 5; + + @Test + public void testSync() { + final TestStatus testStatus = new TestStatus(); + testStatus.maxCount = 1000; + testStatus.completeCount = 0; + + SingleFlight singleFlight = new SingleFlight(); + for (int i = 0; i < testStatus.maxCount; i++) { + singleFlightPerform(singleFlight, i, RetryCount, false, new CompleteHandler() { + @Override + public void complete() throws Exception { + testStatus.completeCount += 1; + LogUtil.d("== sync completeCount:" + testStatus.completeCount); + } + }); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return testStatus.maxCount != testStatus.completeCount; + } + }, 60); + } + + @Test + public void testSyncRetry() { + final TestStatus testStatus = new TestStatus(); + testStatus.maxCount = 1000; + testStatus.completeCount = 0; + + SingleFlight singleFlight = new SingleFlight(); + for (int i = 0; i < testStatus.maxCount; i++) { + singleFlightPerform(singleFlight, i, 0, false, new CompleteHandler() { + @Override + public void complete() throws Exception { + testStatus.completeCount += 1; + LogUtil.d("== sync completeCount:" + testStatus.completeCount); + } + }); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return testStatus.maxCount != testStatus.completeCount; + } + }, 60); + } + + @Test + public void testAsync() { + final TestStatus testStatus = new TestStatus(); + testStatus.maxCount = 1000; + testStatus.completeCount = 0; + + SingleFlight singleFlight = new SingleFlight(); + for (int i = 0; i < testStatus.maxCount; i++) { + singleFlightPerform(singleFlight, i, RetryCount, true, new CompleteHandler() { + @Override + public void complete() throws Exception { + synchronized (testStatus) { + testStatus.completeCount += 1; + } + LogUtil.d("== async complete Count:" + testStatus.completeCount); + } + }); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return testStatus.maxCount != testStatus.completeCount; + } + }, 60); + + assertTrue("== async" + "max Count:" + testStatus.maxCount + " complete Count:" + testStatus.completeCount, testStatus.maxCount == testStatus.completeCount); + LogUtil.d("== async" + "max Count:" + testStatus.maxCount + " complete Count:" + testStatus.completeCount); + } + + @Test + public void testAsyncRetry() { + final TestStatus testStatus = new TestStatus(); + testStatus.maxCount = 1000; + testStatus.completeCount = 0; + + SingleFlight singleFlight = new SingleFlight(); + for (int i = 0; i < testStatus.maxCount; i++) { + singleFlightPerform(singleFlight, i, 0, true, new CompleteHandler() { + @Override + public void complete() throws Exception { + synchronized (testStatus) { + testStatus.completeCount += 1; + } + LogUtil.d("== async completeCount:" + testStatus.completeCount); + } + }); + } + + wait(new WaitConditional() { + @Override + public boolean shouldWait() { + return testStatus.maxCount != testStatus.completeCount; + } + }, 60); + + LogUtil.d("== async completeCount:" + testStatus.completeCount + " end"); + } + + private void singleFlightPerform(final SingleFlight singleFlight, + final int index, + final int retryCount, + final boolean isAsync, + final CompleteHandler completeHandler) { + + try { + singleFlight.perform("key", new SingleFlight.ActionHandler() { + @Override + public void action(final SingleFlight.CompleteHandler singleFlightCompleteHandler) throws Exception { + + final CompleteHandler completeHandlerP = new CompleteHandler() { + @Override + public void complete() throws Exception { + if (retryCount < RetryCount) { + LogUtil.d("== " + (isAsync ? "async" : "sync") + " action retryCount:" + retryCount + " index:" + index + " error"); + throw new Exception("== 123 =="); + } else { + LogUtil.d("== " + (isAsync ? "async" : "sync") + " action retryCount:" + retryCount + " index:" + index + " value"); + singleFlightCompleteHandler.complete(index + ""); + } + } + }; + + if (isAsync) { + new Thread(new Runnable() { + @Override + public void run() { + try { + completeHandlerP.complete(); + } catch (Exception e) { + singleFlightCompleteHandler.complete(null); + } + } + }).start(); + } else { + completeHandlerP.complete(); + } + } + }, new SingleFlight.CompleteHandler() { + @Override + public void complete(Object value) { + if (retryCount < RetryCount) { + singleFlightPerform(singleFlight, index, retryCount + 1, isAsync, completeHandler); + } else { + LogUtil.d("== " + (isAsync ? "async" : "sync") + " action complete retryCount:" + retryCount + " value:" + value + " index:" + index); + if (!isAsync) { + assertTrue("index:" + index + "value error",(value + "").equals(index + "")); + } + try { + completeHandler.complete(); + } catch (Exception e) { + } + } + } + }); + } catch (Exception e) { + singleFlightPerform(singleFlight, index, retryCount + 1, isAsync, completeHandler); + } + } + + + + private interface CompleteHandler { + void complete() throws Exception; + } + + + protected static class TestStatus { + int maxCount; + int completeCount; + } + +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/StringUtilsTest.java b/library/src/androidTest/java/com/qiniu/android/utils/StringUtilsTest.java new file mode 100644 index 000000000..017451332 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/StringUtilsTest.java @@ -0,0 +1,60 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class StringUtilsTest extends BaseTest { + + @Test + public void testJoin(){ + + String string = ""; + + string = StringUtils.join(new String[]{"1", "2"}, "-"); + assertTrue(string.equals("1-2")); + + string = StringUtils.jsonJoin(new String[]{"1", "2"}); + assertTrue(string.equals("\"1\",\"2\"")); + + } + + @Test + public void testTransform(){ + + String string = ""; + + string = StringUtils.jsonJoin(new Long[]{1L, 2L}); + assertTrue(string.equals("\"1\",\"2\"")); + + String[] stringArray = StringUtils.longToString(new Long[]{1L, 2L}); + assertTrue(stringArray.length == 2); + + string = "1234"; + byte[] data = StringUtils.toByteArray(string); + byte[] dataR = new byte[]{-84, -19, 0, 5, 116, 0, 4, 49, 50, 51, 52}; + assertTrue(new String(dataR).equals(new String(data))); + + Object stringR = StringUtils.toObject(dataR); + assertTrue(stringR.equals(string)); + + + string = "tom"; + string = StringUtils.upperCase(string); + assertTrue(string.equals("Tom")); + } + + @Test + public void testToken(){ + String token = "jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu:mWEhowqz4sG301DXU6CB3IO7Zss=:eyJzY29wZSI6InpvbmUxLXNwYWNlIiwiZGVhZGxpbmUiOjE1OTczOTMzOTYsICJyZXR1cm5Cb2R5Ijoie1wiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + String ak = StringUtils.getAkAndScope(token); + assertTrue(ak.equals("jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22euzone1-space")); + + String bucket = StringUtils.getBucket(token); + assertTrue(bucket.equals("zone1-space")); + } +} diff --git a/library/src/androidTest/java/com/qiniu/android/utils/UtilsTest.java b/library/src/androidTest/java/com/qiniu/android/utils/UtilsTest.java new file mode 100644 index 000000000..e47ae9494 --- /dev/null +++ b/library/src/androidTest/java/com/qiniu/android/utils/UtilsTest.java @@ -0,0 +1,77 @@ +package com.qiniu.android.utils; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.qiniu.android.BaseTest; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(AndroidJUnit4.class) +public class UtilsTest extends BaseTest { + + @Test + public void testIPType(){ + + String testHost = "host"; + String type = ""; + + type = Utils.getIpType("10.10.120.3", testHost); + assertTrue(type.equals(testHost + "-10-10")); + + type = Utils.getIpType("130.101.120.3", testHost); + assertTrue(type.equals(testHost + "-130-101")); + + type = Utils.getIpType("2000:0000:0000:0000:0001:2345:6789:abcd", testHost); + assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); + + type = Utils.getIpType("2000:0:0:0:0001:2345:6789:abcd", testHost); + assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); + + type = Utils.getIpType("2000::0001:2345:6789:abcd", testHost); + assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); + } + + @Test + public void testIsIPType(){ + + String ip = null; + boolean isIpv6 = false; + + ip = "10.10.120.3"; + isIpv6 = Utils.isIpv6(ip); + assertFalse(ip, isIpv6); + + ip = "130.101.120.3"; + isIpv6 = Utils.isIpv6(ip); + assertFalse(ip, isIpv6); + + ip = "2000:0000:0000:0000:0001:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "2000:0:0:0:0001:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "2000::0001:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "0::0"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "ffff::ffff:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "ff1::ffff:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertTrue(ip, isIpv6); + + ip = "ffff1::ffff:2345:6789:abcd"; + isIpv6 = Utils.isIpv6(ip); + assertFalse(ip, isIpv6); + } +} From 2d98a2a6e49355b97c365ed2f45afa2bd93e62c2 Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 28 Jul 2022 11:07:22 +0800 Subject: [PATCH 02/12] update test case lib --- .../com/qiniu/android/AndroidNetworkTest.java | 18 - .../java/com/qiniu/android/AsynTest.java | 144 ------- .../java/com/qiniu/android/Base64Test.java | 12 - .../android/BigDataConfigurationTest.java | 25 -- .../java/com/qiniu/android/CancelTest.java | 313 -------------- .../java/com/qiniu/android/ClientTest.java | 78 ---- .../com/qiniu/android/CollectConfigTest.java | 26 -- .../qiniu/android/ComplexUploadSceneTest.java | 133 ------ .../android/ConcurrentResumeUploadTest.java | 323 --------------- .../com/qiniu/android/ConnectCheckTest.java | 46 --- .../java/com/qiniu/android/ContextTest.java | 13 - .../java/com/qiniu/android/DnsApiTest.java | 120 ------ .../com/qiniu/android/DnsCacheFileTest.java | 58 --- .../com/qiniu/android/DnsTransactionTest.java | 122 ------ .../java/com/qiniu/android/EtagTest.java | 53 --- .../com/qiniu/android/FormUploadTest.java | 231 ----------- .../java/com/qiniu/android/GZipTest.java | 50 --- .../java/com/qiniu/android/HappyDnsTest.java | 28 -- .../com/qiniu/android/HttpHeaderTest.java | 112 ----- .../java/com/qiniu/android/HttpTest.java | 305 -------------- .../java/com/qiniu/android/HttpsTest.java | 117 ------ .../java/com/qiniu/android/JsonTest.java | 112 ----- .../com/qiniu/android/ListVectorTest.java | 76 ---- .../java/com/qiniu/android/LogUtilsTest.java | 47 --- .../java/com/qiniu/android/NetworkTest.java | 15 - .../java/com/qiniu/android/PipelineTest.java | 173 -------- .../qiniu/android/RequestTransactionTest.java | 192 --------- .../com/qiniu/android/ResponseInfoTest.java | 34 -- .../com/qiniu/android/ResumeUploadTest.java | 382 ------------------ .../java/com/qiniu/android/RetryTest.java | 207 ---------- .../com/qiniu/android/ServerConfigTest.java | 67 --- .../com/qiniu/android/SingleFlightTest.java | 188 --------- .../com/qiniu/android/StringUtilsTest.java | 52 --- .../com/qiniu/android/SyncFormUploadTest.java | 198 --------- .../java/com/qiniu/android/SystemDnsTest.java | 36 -- .../qiniu/android/SystemHttpClientTest.java | 111 ----- .../com/qiniu/android/TestFileRecorder.java | 229 ----------- .../java/com/qiniu/android/TokenTest.java | 39 -- .../com/qiniu/android/UploadBaseTest.java | 276 ------------- .../qiniu/android/UploadDomainRegionTest.java | 31 -- .../com/qiniu/android/UploadFlowTest.java | 362 ----------------- .../qiniu/android/UploadInfoReporterTest.java | 115 ------ .../qiniu/android/UploadReportItemTest.java | 100 ----- .../UploadServerFreezeManagerTest.java | 31 -- .../java/com/qiniu/android/UplogTest.java | 72 ---- .../java/com/qiniu/android/UriTest.java | 197 --------- .../java/com/qiniu/android/UtilsTest.java | 69 ---- 47 files changed, 5738 deletions(-) delete mode 100644 library/src/androidTest/java/com/qiniu/android/AndroidNetworkTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/AsynTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/Base64Test.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/BigDataConfigurationTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/CancelTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ClientTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/CollectConfigTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ComplexUploadSceneTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ConcurrentResumeUploadTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ConnectCheckTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ContextTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/DnsApiTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/DnsCacheFileTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/DnsTransactionTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/EtagTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/FormUploadTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/GZipTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/HappyDnsTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/HttpHeaderTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/HttpTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/HttpsTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/JsonTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ListVectorTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/LogUtilsTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/NetworkTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/PipelineTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/RequestTransactionTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ResponseInfoTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ResumeUploadTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/RetryTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/ServerConfigTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/SingleFlightTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/StringUtilsTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/SyncFormUploadTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/SystemDnsTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/SystemHttpClientTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/TestFileRecorder.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/TokenTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadBaseTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadDomainRegionTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadFlowTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadInfoReporterTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadReportItemTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UploadServerFreezeManagerTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UplogTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UriTest.java delete mode 100644 library/src/androidTest/java/com/qiniu/android/UtilsTest.java diff --git a/library/src/androidTest/java/com/qiniu/android/AndroidNetworkTest.java b/library/src/androidTest/java/com/qiniu/android/AndroidNetworkTest.java deleted file mode 100644 index 30250c08a..000000000 --- a/library/src/androidTest/java/com/qiniu/android/AndroidNetworkTest.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.AndroidNetwork; -import com.qiniu.android.utils.ContextGetter; - -public class AndroidNetworkTest extends BaseTest { - - public void testHostIP(){ - String ip = AndroidNetwork.getHostIP(); - assertTrue(ip != null); - } - - public void testNetworkType(){ - String type = AndroidNetwork.networkType(ContextGetter.applicationContext()); - assertTrue(type != null); - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/AsynTest.java b/library/src/androidTest/java/com/qiniu/android/AsynTest.java deleted file mode 100644 index 50d6aca3d..000000000 --- a/library/src/androidTest/java/com/qiniu/android/AsynTest.java +++ /dev/null @@ -1,144 +0,0 @@ -package com.qiniu.android; - -import android.os.Looper; - -import com.qiniu.android.utils.AsyncRun; -import com.qiniu.android.utils.LogUtil; - - -public class AsynTest extends BaseTest { - - private class TestParam { - int maxCount; - int completeCount; - int successCount; - } - - public void testAsyncMainOnMainThread() { - - final TestParam testParam = new TestParam(); - testParam.maxCount = 100; - testParam.completeCount = 0; - testParam.successCount = 0; - for (int i = 0; i < testParam.maxCount; i++) { - final int i_p = i; - AsyncRun.runInMain(new Runnable() { - @Override - public void run() { - - if (Thread.currentThread() == Looper.getMainLooper().getThread()) { - testParam.successCount += 1; - } - - String threadName = Thread.currentThread().getName(); - LogUtil.d("thread name:" + threadName); - - testParam.completeCount += 1; - } - }); - } - - WaitConditional waitConditional = new WaitConditional() { - @Override - public boolean shouldWait() { - if (testParam.completeCount == testParam.maxCount) { - return false; - } else { - return true; - } - } - }; - - wait(waitConditional, 5); - - LogUtil.i(String.format("success count: %d", testParam.successCount)); - assertTrue((testParam.successCount == testParam.maxCount)); - } - - public void testAsyncMainOnOtherThread() { - - final TestParam testParam = new TestParam(); - testParam.maxCount = 10; - testParam.completeCount = 0; - testParam.successCount = 0; - for (int i = 0; i < testParam.maxCount; i++) { - final int i_p = i; - - new Thread(new Runnable() { - @Override - public void run() { - AsyncRun.runInMain(new Runnable() { - @Override - public void run() { - - if (Thread.currentThread() == Looper.getMainLooper().getThread()) { - testParam.successCount += 1; - } - - String threadName = Thread.currentThread().getName(); - LogUtil.d("thread name:" + threadName); - - testParam.completeCount += 1; - } - }); - } - }).start(); - } - - WaitConditional waitConditional = new WaitConditional() { - @Override - public boolean shouldWait() { - if (testParam.completeCount == testParam.maxCount) { - return false; - } else { - return true; - } - } - }; - - wait(waitConditional, 5); - - LogUtil.i(String.format("success count: %d", testParam.successCount)); - assertTrue((testParam.successCount == testParam.maxCount)); - } - - public void testAsyncBg() { - final TestParam testParam = new TestParam(); - testParam.maxCount = 100; - testParam.completeCount = 0; - testParam.successCount = 0; - for (int i = 0; i < testParam.maxCount; i++) { - final int i_p = i; - AsyncRun.runInBack(new Runnable() { - @Override - public void run() { - String threadName = Thread.currentThread().getName(); - if (Thread.currentThread() != Looper.getMainLooper().getThread()) { - synchronized (this) { - testParam.successCount += 1; - } - } - synchronized (this) { - testParam.completeCount += 1; - } - } - }); - } - - WaitConditional waitConditional = new WaitConditional() { - @Override - public boolean shouldWait() { - if (testParam.completeCount == testParam.maxCount) { - return false; - } else { - return true; - } - } - }; - - wait(waitConditional, 5); - - LogUtil.i(String.format("success count: %d", testParam.successCount)); - assertTrue("pass", (testParam.successCount == testParam.maxCount)); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/Base64Test.java b/library/src/androidTest/java/com/qiniu/android/Base64Test.java deleted file mode 100644 index 0b576321c..000000000 --- a/library/src/androidTest/java/com/qiniu/android/Base64Test.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.UrlSafeBase64; -import java.io.UnsupportedEncodingException; - -public class Base64Test extends BaseTest { - public void testEncode() throws UnsupportedEncodingException { - String data = "你好/+="; - String result = UrlSafeBase64.encodeToString(data); - assertEquals("5L2g5aW9Lys9", result); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/BigDataConfigurationTest.java b/library/src/androidTest/java/com/qiniu/android/BigDataConfigurationTest.java deleted file mode 100644 index 6440f97a6..000000000 --- a/library/src/androidTest/java/com/qiniu/android/BigDataConfigurationTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; - -import com.qiniu.android.bigdata.Configuration; - -public class BigDataConfigurationTest extends AndroidTestCase { - - public void testCopy() { - Configuration configuration = new Configuration(); - configuration.connectTimeout = 15; - - Configuration configurationCopy = Configuration.copy(configuration); - - assertTrue(configurationCopy.connectTimeout == configuration.connectTimeout); - } - - public void testCopyNoValue() { - Configuration configuration = null; - - Configuration configurationCopy = Configuration.copy(configuration); - - assertTrue(configurationCopy != null); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/CancelTest.java b/library/src/androidTest/java/com/qiniu/android/CancelTest.java deleted file mode 100644 index ef340c9ea..000000000 --- a/library/src/androidTest/java/com/qiniu/android/CancelTest.java +++ /dev/null @@ -1,313 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.common.ZoneInfo; -import com.qiniu.android.common.ZonesInfo; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCancellationSignal; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UpProgressHandler; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.storage.FileRecorder; -import com.qiniu.android.utils.LogUtil; - -import junit.framework.Assert; - -import org.json.JSONObject; - -import java.io.File; -import java.io.IOException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; - -/** - * Created by Simon on 2015/4/15. - */ -public class CancelTest extends BaseTest { - private volatile UploadManager uploadManager; - private volatile UploadOptions options; - - @Override - protected void setUp() throws Exception { - File f = File.createTempFile("qiniutest", "b"); - String folder = f.getParent(); - FileRecorder fr = new FileRecorder(folder); - uploadManager = new UploadManager(fr); - } - - - public void testFile() throws Throwable { - Temp[] ts = new Temp[]{templateFile(8 * 1024 + 1, 0.6)}; - checkTemp(ts, "testFile"); - } - - public void testMultiFile() throws Throwable { - Temp[] ts = new Temp[]{templateFile(400, 0.01), templateFile(700, 0.02), templateFile(1024, 0.02), templateFile(4 * 1024, 0.02), templateFile(8 * 1024 + 1, 0.2)}; - checkTemp(ts, "testFile"); - } - -// public void testData() throws Throwable { -// Temp[] ts = new Temp[]{templateData(400, 0.2), templateData(700, 0.2), templateData(1024, 0.51), templateData(4 * 1024 + 785, 0.5), templateData(4 * 1024, 0.5), templateData(8 * 1024, 0.6)}; -// checkTemp(ts, "testData"); -// } - - private void checkTemp(Temp[] ts, String type) { - int failedCount = 0; - Temp tt = null; - - for (int i = 0; i < ts.length; i++) { - Temp t = ts[i]; - boolean b = t.expectKey.equals(t.key) && t.info.isCancelled() && (t.resp == null); - if (!b) { - tt = t; - failedCount++; - } - } - - LogUtil.d(type + " " + failedCount); - if (failedCount > ts.length / 2) { - String info = type + ": 共 " + ts.length + "个测试，至多允许 " + ts.length / 2 + " 失败，实际失败 " + failedCount + " 个： " + tt.info.toString(); - Assert.assertEquals(info, tt.expectKey, tt.key); - } - } - - - private Temp templateFile(final int size, final double pos) throws Throwable { - final CountDownLatch signal = new CountDownLatch(1); - final File tempFile = TempFile.createFile(size); - final String expectKey = "file_" + size; - Map params = new HashMap(); - params.put("x:a", "test"); - params.put("x:b", "test2"); - - final Temp temp = new Temp(); - temp.cancelled = false; - - Thread t = new Thread() { - public void run() { - try { - Thread.sleep(8 * 60 * 1000); - temp.cancelled = true; - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - }; - t.setDaemon(true); - t.start(); - - final WaitCondition waitCondition = new WaitCondition(); - - options = new UploadOptions(params, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - if (percent >= pos) { - temp.cancelled = true; - } - LogUtil.i(pos + ": progress " + percent); - } - }, new UpCancellationSignal() { - @Override - public boolean isCancelled() { - return temp.cancelled; - } - }); - - uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - temp.expectKey = expectKey; - temp.key = k; - temp.info = rinfo; - temp.resp = response; - signal.countDown(); - LogUtil.i(k + rinfo); - - waitCondition.shouldWait = false; - } - }, options); - - wait(waitCondition, 10 * 60); - assertTrue(temp.info != null); - assertTrue(temp.info.statusCode == ResponseInfo.Cancelled); - - - waitCondition.shouldWait = true; - - // 断点续传 - options = new UploadOptions(params, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - LogUtil.i(pos + ": progress " + percent); - } - }, null); - uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - temp.expectKey = expectKey; - temp.key = k; - temp.info = rinfo; - temp.resp = response; - signal.countDown(); - LogUtil.i(k + rinfo); - - waitCondition.shouldWait = false; - } - }, options); - - wait(waitCondition, 10 * 60); - - assertTrue(temp.info != null); - assertTrue(temp.info.isOK()); - - TempFile.remove(tempFile); - return temp; - } - - private Temp templateData(final int size, final double pos) throws Throwable { - final CountDownLatch signal = new CountDownLatch(1); - final byte[] tempDate = TempFile.getByte(1024 * size); - final String expectKey = "data_" + UUID.randomUUID().toString(); - Map params = new HashMap(); - params.put("x:a", "test"); - params.put("x:b", "test2"); - - final Temp temp = new Temp(); - temp.cancelled = false; - - Thread t = new Thread() { - public void run() { - try { - Thread.sleep(8 * 60 * 1000); - temp.cancelled = true; - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - }; - t.setDaemon(true); - t.start(); - - options = new UploadOptions(params, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - if (percent >= pos) { - temp.cancelled = true; - } - LogUtil.i(pos + ": progress " + percent); - } - }, new UpCancellationSignal() { - @Override - public boolean isCancelled() { - return temp.cancelled; - } - }); - - uploadManager.put(tempDate, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - temp.expectKey = expectKey; - temp.key = k; - temp.info = rinfo; - temp.resp = response; - signal.countDown(); - LogUtil.i(k + rinfo); - } - }, options); - - - try { - signal.await(570, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", temp.info); - } catch (InterruptedException e) { - e.printStackTrace(); - } - return temp; - } - - public void testSwitchRegion() throws IOException { - - final CountDownLatch signal = new CountDownLatch(1); - final File tempFile = TempFile.createFile(5*1024); - final String expectKey = "file_" + UUID.randomUUID().toString(); - Map params = new HashMap(); - params.put("x:a", "test"); - params.put("x:b", "test2"); - - final Temp temp = new Temp(); - temp.cancelled = false; - - Thread t = new Thread() { - public void run() { - try { - Thread.sleep(8 * 60 * 1000); - temp.cancelled = true; - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - }; - t.setDaemon(true); - t.start(); - - final WaitCondition waitCondition = new WaitCondition(); - - options = new UploadOptions(params, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - LogUtil.i("progress " + percent); - } - }, null); - - File f = File.createTempFile("qiniutest", "b"); - String folder = f.getParent(); - FileRecorder fr = new FileRecorder(folder); - - ArrayList hostArray0 = new ArrayList<>(); - hostArray0.add("mock1.up.qiniup.com"); - ZoneInfo zoneInfo0 = ZoneInfo.buildInfo(hostArray0, null, null); - ArrayList hostArray1 = new ArrayList<>(); - hostArray1.add("up-na0.qiniup.com"); - ZoneInfo zoneInfo1 = ZoneInfo.buildInfo(hostArray1, null, null); - - ArrayList zoneInfoArray = new ArrayList<>(); - zoneInfoArray.add(zoneInfo0); - zoneInfoArray.add(zoneInfo1); - ZonesInfo zonesInfo = new ZonesInfo(zoneInfoArray); - FixedZone zone = new FixedZone(zonesInfo); - - Configuration config = new Configuration.Builder().recorder(fr).zone(zone).build(); - - UploadManager uploadManager = new UploadManager(config); - uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - temp.expectKey = expectKey; - temp.key = k; - temp.info = rinfo; - temp.resp = response; - signal.countDown(); - LogUtil.i(k + rinfo); - - waitCondition.shouldWait = false; - } - }, options); - - wait(waitCondition, 10 * 60); - - assertTrue(temp.info != null); - assertTrue(temp.info.toString(), temp.info.isOK()); - - TempFile.remove(tempFile); - } - - private static class Temp { - volatile ResponseInfo info; - volatile JSONObject resp; - volatile String key; - volatile String expectKey; - volatile boolean cancelled; - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ClientTest.java b/library/src/androidTest/java/com/qiniu/android/ClientTest.java deleted file mode 100644 index d95604718..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ClientTest.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.bigdata.client.Client; -import com.qiniu.android.bigdata.client.CompletionHandler; -import com.qiniu.android.bigdata.client.PostArgs; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.UpToken; -import com.qiniu.android.utils.StringMap; - -import org.json.JSONObject; - -public class ClientTest extends BaseTest { - - public void testSyncGet() { - - Client client = new Client(null, 90, 90, null, null); - ResponseInfo responseInfo = client.syncGet("https://up.qiniup.com/crossdomain.xml", null); - assertTrue(responseInfo != null); - assertTrue(responseInfo.statusCode == 200); - } - - public void testAsyncGet() { - - final WaitCondition waitCondition = new WaitCondition(); - Client client = new Client(); - client.asyncGet("https://up.qiniup.com/crossdomain.xml", null, null, new CompletionHandler() { - @Override - public void complete(ResponseInfo info, JSONObject response) { - - assertTrue(info != null); - assertTrue(info.statusCode == 200); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 10 * 60); - } - - public void testMultipartSyncPost() { - - PostArgs postArgs = new PostArgs(); - postArgs.data = "123".getBytes(); - postArgs.mimeType = "text/plain"; - postArgs.params = new StringMap(); - postArgs.params.put("x:foo", "foo"); - - UpToken token = UpToken.parse(TestConfig.commonToken); - - Client client = new Client(null, 90, 90, null, null); - ResponseInfo responseInfo = client.syncMultipartPost("http://up.qiniu.com", postArgs, token); - - assertTrue(responseInfo != null); - } - - public void testMultipartAsyncPost() { - - final WaitCondition waitCondition = new WaitCondition(); - - PostArgs postArgs = new PostArgs(); - postArgs.data = "123".getBytes(); - postArgs.mimeType = "text/plain"; - postArgs.params = new StringMap(); - - UpToken token = UpToken.parse(TestConfig.commonToken); - - Client client = new Client(null, 90, 90, null, null); - client.asyncMultipartPost("http://up.qiniu.com", postArgs, token, null, new CompletionHandler() { - @Override - public void complete(ResponseInfo info, JSONObject response) { - - assertTrue(info != null); - waitCondition.shouldWait = false; - } - }, null); - - wait(waitCondition, 10 * 60); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/CollectConfigTest.java b/library/src/androidTest/java/com/qiniu/android/CollectConfigTest.java deleted file mode 100644 index c5fb60b83..000000000 --- a/library/src/androidTest/java/com/qiniu/android/CollectConfigTest.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; - -import com.qiniu.android.common.Config; - -public class CollectConfigTest extends AndroidTestCase { - - public void testQuick(){ - Config.quick(); - assertTrue(Config.uploadThreshold == 1024); - assertTrue(Config.interval == 2); - } - - public void testNormal(){ - Config.normal(); - assertTrue(Config.uploadThreshold == 4*1024); - assertTrue(Config.interval == 10); - } - - public void testSlow(){ - Config.slow(); - assertTrue(Config.uploadThreshold == 150*1024); - assertTrue(Config.interval == 300); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ComplexUploadSceneTest.java b/library/src/androidTest/java/com/qiniu/android/ComplexUploadSceneTest.java deleted file mode 100644 index 0a9456b87..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ComplexUploadSceneTest.java +++ /dev/null @@ -1,133 +0,0 @@ -package com.qiniu.android; - -import android.util.Log; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCompletionHandler; - -import org.json.JSONObject; - -import java.io.File; -import java.io.IOException; -import java.util.concurrent.CountDownLatch; - -public class ComplexUploadSceneTest extends UploadBaseTest { - - private final CountDownLatch signal = new CountDownLatch(1); - - public void testMutiUploadV1() { - - final int maxCount = 40; - - final TestParam param = new TestParam(); - param.completeCount = 0; - param.successCount = 0; - - final int start = 37; - for (int i = start; i < maxCount; i++) { - Configuration config = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .concurrentTaskCount(3) - .chunkSize((i % 4 + 1) * 1024 * 1024 + i) - .build(); - - int size = (i + 1) * 1024; - final String keyUp = "android_complex_upload_v1_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size); - } catch (IOException e) { - continue; - } - - UploadInfo info = new UploadInfo<>(file); - info.configWithFile(file); - upload(info, keyUp, config, null, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - synchronized (param) { - param.completeCount += 1; - if (info != null && info.isOK()) { - param.successCount += 1; - } - if (param.completeCount == (maxCount - start)) { - signal.countDown(); - } - } - Log.d("upload key:" + keyUp, "complex_upload_v1 response: " + info); - } - }); - } - - try { - signal.await(); // wait for callback - } catch (InterruptedException e) { - } - - Log.d("ComplexUploadSceneTest", "complex_upload_v1 successCount: " + param.successCount); - assertTrue("success count" + param.successCount, param.successCount == param.completeCount); - } - - public void testMutiUploadV2() { - - final int maxCount = 40; - - final TestParam param = new TestParam(); - param.completeCount = 0; - param.successCount = 0; - - final int start = 37; - for (int i = start; i < maxCount; i++) { - Configuration config = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .concurrentTaskCount(3) - .chunkSize((i % 4 + 1) * 1024 * 1024 + i) - .build(); - - int size = (i + 1) * 1024; - final String keyUp = "android_complex_upload_v2_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size); - } catch (IOException e) { - continue; - } - - UploadInfo info = new UploadInfo<>(file); - info.configWithFile(file); - upload(info, keyUp, config, null, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - synchronized (param) { - param.completeCount += 1; - if (info != null && (info.isOK() || info.statusCode == 614)) { - param.successCount += 1; - } - if (param.completeCount == (maxCount - start)) { - signal.countDown(); - } - } - Log.d("upload key:" + keyUp, "complex_upload_v2 response: " + info); - } - }); - } - - try { - signal.await(); // wait for callback - } catch (InterruptedException e) { - } - - Log.d("ComplexUploadSceneTest", "complex_upload_v2 successCount: " + param.successCount); - assertTrue("success count" + param.successCount, param.successCount == (param.completeCount)); - } - - - private class TestParam { - int successCount = 0; - int completeCount = 0; - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/ConcurrentResumeUploadTest.java b/library/src/androidTest/java/com/qiniu/android/ConcurrentResumeUploadTest.java deleted file mode 100644 index 20d90b2cf..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ConcurrentResumeUploadTest.java +++ /dev/null @@ -1,323 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; - -import java.io.File; -import java.io.IOException; -import java.util.Date; - - -/** - * Created by yangsen on 2020/5/27 - */ -public class ConcurrentResumeUploadTest extends UploadFlowTest { - - public void testSwitchRegionV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - int[] sizeArray = {5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_switch_region_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - switchRegionTestWithFile(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testCancelV1() { - float cancelPercent = (float) 0.5; - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - int[] sizeArray = {10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_cancel_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - cancelTest((long) (size * cancelPercent), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_http_v1_new_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpsV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_https_v1_new_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testReuploadV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .chunkSize(1024 * 1024) - .build(); - int[] sizeArray = {30000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_reupload_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - reuploadUploadTest((long) (size * 0.5), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testNoKeyV1() { - int size = 600; - String key = "android_concurrent_resume_no_key_v1_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); - - TempFile.remove(file); - } - - public void test0kV1() { - int size = 0; - String key = "android_concurrent_resume_0k_v1_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); - - TempFile.remove(file); - } - - - public void testSwitchRegionV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .chunkSize(4 * 1024 * 1024) - .useHttps(true) - .build(); - int[] sizeArray = {5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_switch_region_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - switchRegionTestWithFile(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testCancelV2() { - float cancelPercent = (float) 0.5; - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .chunkSize(4 * 1024 * 1024) - .useHttps(true) - .build(); - int[] sizeArray = {10000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_cancel_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - cancelTest((long) (size * cancelPercent), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .chunkSize(4 * 1024 * 1024) - .useHttps(false) - .build(); - int[] sizeArray = {500, 2000, 4000, 5000, 8000, 20000}; - long timestamp = new Date().getTime(); - for (int size : sizeArray) { - String key = "android_concurrent_resume_http_v2_" + timestamp + "_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpsV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(true) - .chunkSize(4 * 1024 * 1024) - .build(); - int[] sizeArray = {500, 2000, 4000, 5000, 8000, 20000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_https_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testReuploadV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(true) - .chunkSize(4 * 1024 * 1024) - .build(); - int[] sizeArray = {30000}; - for (int size : sizeArray) { - String key = "android_concurrent_resume_reupload_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - reuploadUploadTest((long) (size * 0.7), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testNoKeyV2() { - int size = 600; - String key = "android_concurrent_resume_no_key_v2_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); - - TempFile.remove(file); - } - - public void test0kV2() { - int size = 0; - String key = "android_concurrent_resume_0k_v2_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); - - TempFile.remove(file); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ConnectCheckTest.java b/library/src/androidTest/java/com/qiniu/android/ConnectCheckTest.java deleted file mode 100644 index d19a4c537..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ConnectCheckTest.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.connectCheck.ConnectChecker; -import com.qiniu.android.storage.GlobalConfiguration; - -public class ConnectCheckTest extends BaseTest { - - public void testCheck() { - - int maxCount = 100; - int successCount = 0; - for (int i = 0; i < maxCount; i++) { - if (ConnectChecker.isConnected(ConnectChecker.check())) { - successCount += 1; - } - } - - assertEquals("maxCount:" + maxCount + " successCount:" + successCount, maxCount, successCount); - } - - public void testCustomCheckHosts() { - GlobalConfiguration.getInstance().connectCheckURLStrings = new String[]{"https://www.baidu.com", "https://www.google.com"}; - int maxCount = 100; - int successCount = 0; - for (int i = 0; i < maxCount; i++) { - if (ConnectChecker.isConnected(ConnectChecker.check())) { - successCount += 1; - } - } - - assertEquals("maxCount:" + maxCount + " successCount:" + successCount, maxCount, successCount); - } - - public void testNotConnected() { - GlobalConfiguration.getInstance().connectCheckURLStrings = new String[]{"https://www.test1.com", "https://www.test2.com"}; - int maxCount = 100; - int successCount = 0; - for (int i = 0; i < maxCount; i++) { - if (ConnectChecker.isConnected(ConnectChecker.check())) { - successCount += 1; - } - } - - assertEquals("maxCount:" + maxCount + " successCount:" + successCount, 0, successCount); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ContextTest.java b/library/src/androidTest/java/com/qiniu/android/ContextTest.java deleted file mode 100644 index f896979f9..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ContextTest.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.qiniu.android; - -import android.content.Context; -import android.test.AndroidTestCase; - -import com.qiniu.android.utils.ContextGetter; - -public class ContextTest extends AndroidTestCase { - public void testEncode() { - Context c = ContextGetter.applicationContext(); - assertNotNull(c); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/DnsApiTest.java b/library/src/androidTest/java/com/qiniu/android/DnsApiTest.java deleted file mode 100644 index cddb2d52c..000000000 --- a/library/src/androidTest/java/com/qiniu/android/DnsApiTest.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.AutoZone; -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.http.dns.DnsPrefetchTransaction; -import com.qiniu.android.http.dns.DnsPrefetcher; -import com.qiniu.android.http.dns.IDnsNetworkAddress; -import com.qiniu.android.storage.UpToken; - -import java.util.List; - -/** - * Created by jemy on 2019/8/20. - */ - -public class DnsApiTest extends BaseTest { - - @Override - protected void setUp() throws Exception { - } - - public void testLocalLoad() { - - final String host = "uplog.qbox.me"; - final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); - dnsPrefetcher.localFetch(); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - List list = dnsPrefetcher.getInetAddressByHost(host); - if (list == null || list.size() == 0){ - return true; - } else { - return false; - } - } - }, 60); - - List addressList = dnsPrefetcher.getInetAddressByHost(host); - assertTrue(addressList.size() > 0); - } - - public void testRecover(){ - final String host = "uplog.qbox.me"; - - final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); - dnsPrefetcher.recoverCache(); - - List addressList = dnsPrefetcher.getInetAddressByHost(host); - assertTrue(addressList.size() > 0); - - dnsPrefetcher.invalidNetworkAddress(addressList.get(0)); - } - - - public void testPreFetch() { - - final String host = "upload.qiniup.com"; - FixedZone fixedZone = new FixedZone(new String[]{host}); - - final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); - dnsPrefetcher.checkAndPrefetchDnsIfNeed(fixedZone, UpToken.parse(TestConfig.token_z0)); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - List list = dnsPrefetcher.getInetAddressByHost(host); - if (list == null || list.size() == 0){ - return true; - } else { - return false; - } - } - }, 60); - - List addressList = dnsPrefetcher.getInetAddressByHost(host); - assertTrue(addressList.size() > 0); - } - - public void testMutiThreadPrefetch(){ - - final AutoZone zone = new AutoZone(); - final TestParam param = new TestParam(); - - for (int i = 0; i < param.count; i++) { - new Thread(new Runnable() { - @Override - public void run() { - boolean isSuccess = DnsPrefetchTransaction.addDnsCheckAndPrefetchTransaction(zone, UpToken.parse(TestConfig.token_z0)); - synchronized (this){ - if (isSuccess){ - param.successCount += 1; - } - param.completeCount += 1; - } - } - }).start(); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (param.completeCount != param.count){ - return true; - } else { - return false; - } - } - }, 60); - - assertTrue((param.successCount <= 1)); - } - - private static class TestParam{ - int count = 100; - int successCount = 0; - int completeCount = 0; - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/DnsCacheFileTest.java b/library/src/androidTest/java/com/qiniu/android/DnsCacheFileTest.java deleted file mode 100644 index 2cad26c48..000000000 --- a/library/src/androidTest/java/com/qiniu/android/DnsCacheFileTest.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.dns.DnsCacheFile; -import com.qiniu.android.storage.GlobalConfiguration; -import com.qiniu.android.utils.LogUtil; - -import java.io.IOException; - -public class DnsCacheFileTest extends BaseTest { - - public void testCreate(){ - try { - DnsCacheFile file = new DnsCacheFile(null); - if (file != null){ - assertTrue(false); - } - } catch (IOException e) { - assertTrue(true); - } - - - DnsCacheFile file = null; - try { - file = new DnsCacheFile(GlobalConfiguration.getInstance().dnsCacheDir); - } catch (IOException e) { - e.printStackTrace(); - } - LogUtil.i("DnsCacheFile name:" + file.getFileName()); - assertTrue(file != null); - - } - - public void testValue(){ - - String dataStringBefore = "123"; - byte[] dataBefore = dataStringBefore.getBytes(); - - DnsCacheFile file = null; - try { - file = new DnsCacheFile(GlobalConfiguration.getInstance().dnsCacheDir); - } catch (IOException e) { - e.printStackTrace(); - } - - file.set("key", dataBefore); - - byte[] dataAfter = file.get("key"); - String dataStringAfter = new String(dataAfter); - - assertTrue(dataStringBefore.equals(dataStringAfter)); - - - file.del("key"); - dataAfter = file.get("key"); - assertTrue(dataAfter == null); - - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/DnsTransactionTest.java b/library/src/androidTest/java/com/qiniu/android/DnsTransactionTest.java deleted file mode 100644 index 2afe03f34..000000000 --- a/library/src/androidTest/java/com/qiniu/android/DnsTransactionTest.java +++ /dev/null @@ -1,122 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.AutoZone; -import com.qiniu.android.common.Zone; -import com.qiniu.android.http.dns.DnsPrefetchTransaction; -import com.qiniu.android.storage.UpToken; - - -/** - * Created by yangsen on 2020/6/9 - */ -public class DnsTransactionTest extends BaseTest { - - private final int maxTestCount = 100; - private int completeCount = 0; - private int successCount = 0; - - public void testLocalLoad(){ - - completeCount = 0; - successCount = 0; - - for (int i = 0; i < maxTestCount; i++) { - new Thread(new Runnable() { - @Override - public void run() { - - boolean isSuccess = DnsPrefetchTransaction.addDnsLocalLoadTransaction(); - if (isSuccess){ - successCount += 1; - } - completeCount += 1; - } - }).start(); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (completeCount < maxTestCount) { - return true; - } else { - return false; - } - } - }, 60); - - assertTrue(successCount < 2); - } - - - public void test_CheckAndPrefetch(){ - - completeCount = 0; - successCount = 0; - - final Zone zone = new AutoZone(); - for (int i = 0; i < maxTestCount; i++) { - new Thread(new Runnable() { - @Override - public void run() { - - boolean isSuccess = DnsPrefetchTransaction.addDnsCheckAndPrefetchTransaction(zone, UpToken.parse(TestConfig.token_z0)); - synchronized (this) { - if (isSuccess) { - successCount += 1; - } - completeCount += 1; - } - } - }).start(); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (completeCount < maxTestCount) { - return true; - } else { - return false; - } - } - }, 60); - - assertTrue("successCount:" + successCount, successCount < 3); - } - - - public void testCheckWhetherCachedValid(){ - - completeCount = 0; - successCount = 0; - - final Zone zone = new AutoZone(); - for (int i = 0; i < maxTestCount; i++) { - new Thread(new Runnable() { - @Override - public void run() { - - boolean isSuccess = DnsPrefetchTransaction.setDnsCheckWhetherCachedValidTransactionAction(); - if (isSuccess){ - successCount += 1; - } - completeCount += 1; - } - }).start(); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (completeCount < maxTestCount) { - return true; - } else { - return false; - } - } - }, 60); - - assertTrue(successCount < 2); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/EtagTest.java b/library/src/androidTest/java/com/qiniu/android/EtagTest.java deleted file mode 100644 index d4234c28b..000000000 --- a/library/src/androidTest/java/com/qiniu/android/EtagTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; - -import com.qiniu.android.common.Constants; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.utils.Etag; - -import junit.framework.Assert; - -import java.io.File; -import java.io.IOException; -import java.io.UnsupportedEncodingException; - -public class EtagTest extends AndroidTestCase { - public void testData() { - String m = Etag.data(new byte[0]); - Assert.assertEquals("Fto5o-5ea0sNMlW_75VgGJCv2AcJ", m); - - try { - String etag = Etag.data("etag".getBytes(Constants.UTF_8)); - Assert.assertEquals("FpLiADEaVoALPkdb8tJEJyRTXoe_", etag); - } catch (UnsupportedEncodingException e) { - e.printStackTrace(); - } - } - - public void testFile() throws IOException { - File f = TempFile.createFile(1024); - Assert.assertEquals("FhHnGzB75K2JC4YOzKDMLEiaeSKm", Etag.file(f)); - TempFile.remove(f); - f = TempFile.createFile(4 * 1024); - Assert.assertEquals("FuPHVcYFMpfuoCTDGF5PCjMY9xxu", Etag.file(f)); - TempFile.remove(f); - f = TempFile.createFile(5 * 1024); - Assert.assertEquals("lkr1cErNyp23IdWan82rufDn3dzT", Etag.file(f)); - TempFile.remove(f); - f = TempFile.createFile(8 * 1024); - Assert.assertEquals("lkRgUHWNADyQ0TRirdqoS7UWFql4", Etag.file(f)); - TempFile.remove(f); - f = TempFile.createFile(9 * 1024); - Assert.assertEquals("lvlmp343GVuq367WF4XTMetchhid", Etag.file(f)); - TempFile.remove(f); - } - - public void testLongToInt() { - long len = 2323435710l; - int b = (int) ((len + Configuration.BLOCK_SIZE - 1) / Configuration.BLOCK_SIZE); - Assert.assertEquals("不应该溢出", 554, b); - int a = (int) (len + Configuration.BLOCK_SIZE - 1) / Configuration.BLOCK_SIZE; - Assert.assertNotSame("预计会溢出", 554, a); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/FormUploadTest.java b/library/src/androidTest/java/com/qiniu/android/FormUploadTest.java deleted file mode 100644 index ee2bcdf53..000000000 --- a/library/src/androidTest/java/com/qiniu/android/FormUploadTest.java +++ /dev/null @@ -1,231 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.http.UrlConverter; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.GlobalConfiguration; -import com.qiniu.android.storage.UploadOptions; - -import junit.framework.Assert; - -import java.io.File; -import java.io.IOException; -import java.util.HashMap; -import java.util.Map; - -public class FormUploadTest extends UploadFlowTest { - - public void testSwitchRegion() { - Configuration configuration = new Configuration.Builder() - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - int[] sizeArray = {5, 50, 200, 500, 800, 1000, 2000, 3000, 4000}; - for (int size : sizeArray) { - String key = "android_Form_switch_region_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - switchRegionTestWithFile(file, key, configuration, null); - } - } - - public void testCancel() { - GlobalConfiguration.getInstance().partialHostFrozenTime = 20*60; - - float cancelPercent = (float) 0.2; - Configuration configuration = new Configuration.Builder() - .connectTimeout(60) - .responseTimeout(30) - .retryMax(0) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - int[] sizeArray = {2000, 3000, 4000}; - for (int size : sizeArray) { - String key = "android_form_cancel_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - Assert.fail(e.getMessage()); - } - cancelTest((long) (size * cancelPercent), file, key, configuration, null); - } - } - - public void testHttp() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(false) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_form_http" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertSuccessResult(file, key, configuration, null); - } - } - - public void testHttps() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(true) - .useHttps(true) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_form_https" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertSuccessResult(file, key, configuration, null); - } - } - - public void testSmall() { - Map params = new HashMap(); - params.put("x:foo", "foo"); - params.put("x:bar", "bar"); - //mime type - final String mimeType = "text/plain"; - final UploadOptions options = new UploadOptions(params, mimeType, true, null, null); - - String key = "android_small"; - File file = null; - try { - file = TempFile.createFile(10, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertSuccessResult(file, key, null, options); - } - - - public void test100up() { - int count = 100; - for (int i = 1; i < count; i++) { - String key = "android_form_100_UP_" + i + "k"; - File file = null; - try { - file = TempFile.createFile(10, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertSuccessResult(file, key, null, null); - } - } - - public void testUpUnAuth() { - String key = "android_unAuth"; - File file = null; - try { - file = TempFile.createFile(10, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "noAuth", "android_form_no_auth", null, null); - } - - public void testNoData() { - String key = "android_noData"; - File file = null; - try { - file = TempFile.createFile(0, key); - } catch (IOException e) { - Assert.assertTrue(e.getMessage(), false); - } - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, null, null); - } - - public void testNoToken() { - String key = "android_form_no_token"; - File file = null; - try { - file = TempFile.createFile(5 * 1024, key); - } catch (IOException e) { - e.printStackTrace(); - } - - uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, null, key, null, null); - - uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "", key, null, null); - - uploadFileAndAssertResult(ResponseInfo.InvalidToken, file, "ABC", key, null, null); - - TempFile.remove(file); - } - - public void testNoKey() { - String key = "android_form_no_key"; - File file = null; - try { - file = TempFile.createFile(5 * 1024, key); - } catch (IOException e) { - e.printStackTrace(); - } - - uploadFileAndAssertSuccessResult(file, null, null, null); - - TempFile.remove(file); - } - - public void testUrlConvert() { - String fileKey = "android_form_url_convert_file_new"; - File file = null; - try { - file = TempFile.createFile(5, fileKey); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configuration = new Configuration.Builder() - .useHttps(false) - .zone(new FixedZone(new String[]{"upnono-na0.qiniu.com", "upnono-na0.qiniu.com"})) - .urlConverter(new UrlConverter() { - @Override - public String convert(String url) { - return url.replace("upnono", "up"); - } - }) - .build(); - uploadFileAndAssertSuccessResult(file, fileKey, configuration, null); - } - - public void testCustomParam() { - - Map userParam = new HashMap<>(); - userParam.put("foo", "foo_value"); - userParam.put("bar", "bar_value"); - - Map metaParam = new HashMap<>(); - metaParam.put("0000", "meta_value_0"); - metaParam.put("x-qn-meta-aaa", "meta_value_1"); - metaParam.put("x-qn-meta-key-2", "meta_value_2"); - - UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); - - String fileKey = "android_form_custom_param_file"; - File file = null; - try { - file = TempFile.createFile(5, fileKey); - } catch (IOException e) { - e.printStackTrace(); - } - uploadFileAndAssertSuccessResult(file, fileKey, null, options); - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/GZipTest.java b/library/src/androidTest/java/com/qiniu/android/GZipTest.java deleted file mode 100644 index 944c6eb3c..000000000 --- a/library/src/androidTest/java/com/qiniu/android/GZipTest.java +++ /dev/null @@ -1,50 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.GZipUtil; -import java.util.Arrays; - -public class GZipTest extends BaseTest { - - public void testGZipString(){ - - String string = null; - - byte[] gzip = GZipUtil.gZip(string); - assertTrue(gzip == null); - - string = ""; - gzip = GZipUtil.gZip(string); - assertTrue(Arrays.equals(gzip, string.getBytes())); - - - string = "ABCDEFG"; - gzip = GZipUtil.gZip(string); - - byte[] gUnzip = GZipUtil.gUnzip(gzip); - String stringGUnzip = new String(gUnzip); - - assertTrue(string.equals(stringGUnzip)); - } - - public void testGZipByte(){ - - byte[] bytes = null; - - byte[] gzip = GZipUtil.gZip(bytes); - assertTrue(gzip == null); - - bytes = new byte[0]; - gzip = GZipUtil.gZip(bytes); - assertTrue(Arrays.equals(bytes, gzip)); - - - String string = "ABCDEFG"; - bytes = string.getBytes(); - gzip = GZipUtil.gZip(bytes); - - byte[] gUnzip = GZipUtil.gUnzip(gzip); - String stringGUnzip = new String(gUnzip); - - assertTrue(string.equals(stringGUnzip)); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/HappyDnsTest.java b/library/src/androidTest/java/com/qiniu/android/HappyDnsTest.java deleted file mode 100644 index 9608ae599..000000000 --- a/library/src/androidTest/java/com/qiniu/android/HappyDnsTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.dns.HappyDns; -import com.qiniu.android.http.dns.IDnsNetworkAddress; - -import java.net.UnknownHostException; -import java.util.ArrayList; -import java.util.List; - -/** - * Created by yangsen on 2020/6/8 - */ -public class HappyDnsTest extends BaseTest { - - public void testDns(){ - - HappyDns happyDns = new HappyDns(); - List inetAddressList = new ArrayList<>(); - - try { - inetAddressList = happyDns.lookup("qiniu.com"); - } catch (UnknownHostException e) { - e.printStackTrace(); - } - - assertTrue(inetAddressList.size() > 0); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/HttpHeaderTest.java b/library/src/androidTest/java/com/qiniu/android/HttpHeaderTest.java deleted file mode 100644 index 41daf154b..000000000 --- a/library/src/androidTest/java/com/qiniu/android/HttpHeaderTest.java +++ /dev/null @@ -1,112 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; - -import com.qiniu.android.http.Headers; -import com.qiniu.android.http.HttpDate; -import com.qiniu.android.utils.LogUtil; - -import java.util.Date; -import java.util.HashMap; - -public class HttpHeaderTest extends AndroidTestCase { - - private Headers headers; - - @Override - protected void setUp() throws Exception { - super.setUp(); - - HashMap keyVaules = new HashMap<>(); - keyVaules.put("date", "2020-07-15 07:40:01"); - keyVaules.put("host", "127.0.0.1"); - headers = Headers.of(keyVaules); - LogUtil.i(headers.names().toString()); - } - - public void testValue() { - - assertTrue(headers.values("date") != null); - assertTrue(headers.values("host") != null); - } - - public void testCount() { - - assertTrue(headers.byteCount() > 0); - } - - public void testBuilder() { - String dateKey = "date"; - String dateValue = HttpDate.format(new Date()); - String hostKey = "host"; - String hostValue = "127.0.0.1"; - - Headers.Builder builder0 = new Headers.Builder(); - builder0.add(dateKey, dateValue); - builder0.add(hostKey + ":" + hostValue); - Headers headers0 = builder0.build(); - - assertTrue(headers0.get(dateKey).equals(dateValue)); - assertTrue(headers0.getDate(dateKey) != null); - assertTrue(headers0.get(hostKey).equals(hostValue)); - - - Headers.Builder builder1 = new Headers.Builder(); - builder1.addAll(headers0); - assertTrue(builder1.get(dateKey).equals(dateValue)); - - - Headers headers1 = headers0.newBuilder().build(); - assertTrue(headers1.equals(headers0)); - assertTrue(headers1.toString().equals(headers0.toString())); - assertTrue(headers1.hashCode() == headers0.hashCode()); - - - Headers headers = Headers.of(hostKey, hostValue, dateKey, dateValue); - assertTrue(headers.get(dateKey).equals(dateValue)); - - - headers1.toMultimap(); - - - builder1.set("time", "2020-07-10 10:20:14"); - headers1 = builder1.build(); - assertTrue(headers1.get("time").equals("2020-07-10 10:20:14")); - - builder1.removeAll("time"); - headers1 = builder1.build(); - assertTrue(headers1.get("time") == null); - } - - - public void testBuilderError() { - - Headers headers = null; - - String headersString = null; - try { - headers = Headers.of(headersString); - } catch (Exception e) { - assertTrue(true); - } - - try { - headers = Headers.of("key"); - } catch (Exception e) { - assertTrue(true); - } - - try { - headers = Headers.of("key", null); - } catch (Exception e) { - assertTrue(true); - } - - try { - headers = Headers.of("key", ""); - } catch (Exception e) { - assertTrue(true); - } - - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/HttpTest.java b/library/src/androidTest/java/com/qiniu/android/HttpTest.java deleted file mode 100644 index f49cec1ea..000000000 --- a/library/src/androidTest/java/com/qiniu/android/HttpTest.java +++ /dev/null @@ -1,305 +0,0 @@ -package com.qiniu.android; - -import android.test.suitebuilder.annotation.SmallTest; - -import com.qiniu.android.bigdata.client.Client; -import com.qiniu.android.bigdata.client.CompletionHandler; -import com.qiniu.android.http.ProxyConfiguration; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.UpToken; -import com.qiniu.android.utils.AsyncRun; -import com.qiniu.android.utils.LogUtil; -import com.qiniu.android.utils.StringMap; - -import junit.framework.Assert; - -import org.json.JSONObject; - -import java.net.URI; -import java.net.URISyntaxException; -import java.nio.charset.Charset; - - -/** - * Created by bailong on 14/10/12. - */ -public class HttpTest extends BaseTest { - private Client httpManager; - private ResponseInfo info; - - private static URI newURI(String s) { - try { - return new URI(s); - } catch (URISyntaxException e) { - e.printStackTrace(); - } - return null; - } - - @Override - protected void setUp() throws Exception { - httpManager = new Client(null, 90, 90, null, null); - } - - @SmallTest - public void testPost1() throws Throwable { - - httpManager.asyncPost("http://www.baidu.com", - "hello".getBytes(), null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - Assert.assertNotNull(rinfo); - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - Assert.assertTrue(info.reqId == ""); - } - - @SmallTest - public void testPost2() throws Throwable { - - httpManager.asyncPost("http://up.qiniu.com", "hello".getBytes(), null, - UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - Assert.assertNotNull(info.reqId); - } - - @SmallTest - public void testPost3() throws Throwable { - AsyncRun.runInMain(new Runnable() { // THIS IS THE KEY TO SUCCESS - public void run() { - - httpManager.asyncPost("http://httpbin.org/status/500", "hello".getBytes(), - null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - } - }); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - Assert.assertEquals(500, info.statusCode); - Assert.assertNotNull(info.error); - } - - @SmallTest - public void testPost4() throws Throwable { - AsyncRun.runInMain(new Runnable() { // THIS IS THE KEY TO SUCCESS - public void run() { - httpManager.asyncPost("http://httpbin.org/status/418", - "hello".getBytes(), - null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - } - }); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 5); - - Assert.assertEquals(418, info.statusCode); - Assert.assertNotNull(info.error); - } - - @SmallTest - public void testPostNoDomain() throws Throwable { - - - httpManager.asyncPost("http://no-domain.qiniu.com", "hello".getBytes(), - null, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - Assert.assertEquals("", info.reqId); - Assert.assertEquals(ResponseInfo.UnknownHost, info.statusCode); - } - -// @SmallTest -// public void testPostNoPort() throws Throwable { -// -// httpManager.asyncPost("http://up.qiniu.com:12345", "hello".getBytes(), -// null, null, new CompletionHandler() { -// @Override -// public void complete(ResponseInfo rinfo, JSONObject response) { -// LogUtil.d(rinfo.toString()); -// info = rinfo; -// signal.countDown(); -// } -// }, null); -// -// try { -// signal.await(60, TimeUnit.SECONDS); // wait for callback -// } catch (InterruptedException e) { -// e.printStackTrace(); -// } -// Assert.assertEquals("", info.reqId); -// Assert.assertTrue(ResponseInfo.CannotConnectToHost == info.statusCode || -// ResponseInfo.TimedOut == info.statusCode); -// } - - @SmallTest - public void testPostIP() throws Throwable { - info = null; - StringMap x = new StringMap().put("Host", "up.qiniu.com"); - - httpManager.asyncPost("http://124.160.115.112", "hello".getBytes(), - x, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - Assert.assertTrue(!"".equals(info.reqId)); - Assert.assertEquals(400, info.statusCode); - } - - @SmallTest - public void testProxy() throws Throwable { - StringMap x = new StringMap(); - ProxyConfiguration p = new ProxyConfiguration("115.238.101.32", 80); - Client c = new Client(p, 10, 30, null, null); - - c.asyncPost("http://upproxy1.qiniu.com", "hello".getBytes(), - x, UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, - null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - Assert.assertTrue(!"".equals(info.reqId)); - Assert.assertEquals(400, info.statusCode); - } - - @SmallTest - public void testHeader() { - // com.qiniu.android.http.UserAgent#getUa - // return new String((ua + "; " + _part + ")").getBytes(Charset.forName("ISO-8859-1"))); - - String name = new String(("电话☎️的の").getBytes(Charset.forName("ISO-8859-1"))); - String value = new String(("sdf✈️he覆盖😁🆚9837-=/ df").getBytes(Charset.forName("ISO-8859-1"))); - checkNameAndValue(name, value); - } - - // copy from okhttp3.Headers - private void checkNameAndValue(String name, String value) { - if (name == null) throw new IllegalArgumentException("name == null"); - if (name.isEmpty()) throw new IllegalArgumentException("name is empty"); - for (int i = 0, length = name.length(); i < length; i++) { - char c = name.charAt(i); - if (c <= '\u001f' || c >= '\u007f') { - throw new IllegalArgumentException(String.format( - "Unexpected char %#04x at %d in header name: %s", (int) c, i, name)); - } - } - if (value == null) throw new IllegalArgumentException("value == null"); - for (int i = 0, length = value.length(); i < length; i++) { - char c = value.charAt(i); - if (c <= '\u001f' || c >= '\u007f') { - throw new IllegalArgumentException(String.format( - "Unexpected char %#04x at %d in %s value: %s", (int) c, i, name, value)); - } - } - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/HttpsTest.java b/library/src/androidTest/java/com/qiniu/android/HttpsTest.java deleted file mode 100644 index 3ed9ba54b..000000000 --- a/library/src/androidTest/java/com/qiniu/android/HttpsTest.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.qiniu.android; - -import android.test.suitebuilder.annotation.SmallTest; - -import com.qiniu.android.bigdata.client.Client; -import com.qiniu.android.bigdata.client.CompletionHandler; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.UpToken; -import com.qiniu.android.utils.LogUtil; - -import org.json.JSONObject; - -import java.net.URI; -import java.net.URISyntaxException; -import java.util.concurrent.CountDownLatch; - -/** - * Created by bailong on 15/12/1. - */ -public class HttpsTest extends BaseTest { - final CountDownLatch signal = new CountDownLatch(1); - private Client httpManager; - private ResponseInfo info; - - private static URI newURI(String s) { - try { - return new URI(s); - } catch (URISyntaxException e) { - e.printStackTrace(); - } - return null; - } - - @Override - protected void setUp() throws Exception { - httpManager = new Client(); - } - - @SmallTest - public void testPost1() throws Throwable { - - info = null; - httpManager.asyncPost("https://www.baidu.com/", "hello".getBytes(), null, - UpToken.parse(TestConfig.commonToken), "hello".getBytes().length, null, new CompletionHandler() { - @Override - public void complete(ResponseInfo rinfo, JSONObject response) { - LogUtil.d(rinfo.toString()); - info = rinfo; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 5); - - - assertEquals(info.error, 200, info.statusCode); - } - -// @SmallTest -// public void testPost2() throws Throwable { -// -// info = null; -// -// httpManager.asyncPost("https://static-fw.qbox.me/public/v28812/add-on/ga/analytics.js", -// "hello".getBytes(), null, UpToken.parse(TestConfig.token_z0), "hello".getBytes().length, -// null, new CompletionHandler() { -// @Override -// public void complete(ResponseInfo rinfo, JSONObject response) { -// LogUtil.d(rinfo.toString()); -// info = rinfo; -// } -// }, null); -// -// wait(new WaitConditional() { -// @Override -// public boolean shouldWait() { -// if (info == null) { -// return true; -// } else { -// return false; -// } -// } -// }, 5); -// -// assertEquals(info.error, 200, info.statusCode); -// assertNotNull(info.reqId); -// } - -// @SmallTest -// public void testPost3() throws Throwable { -// httpManager.asyncPost("https://up.qiniu.com", -// "hello".getBytes(), null, null, new CompletionHandler() { -// @Override -// public void complete(ResponseInfo rinfo, JSONObject response) { -// LogUtil.d(rinfo.toString()); -// info = rinfo; -// signal.countDown(); -// } -// }, null); -// -// try { -// signal.await(60000, TimeUnit.SECONDS); // wait for callback -// } catch (InterruptedException e) { -// e.printStackTrace(); -// } -// // cert is not match -// Assert.assertEquals(info.error, -1, info.statusCode); -// } -} diff --git a/library/src/androidTest/java/com/qiniu/android/JsonTest.java b/library/src/androidTest/java/com/qiniu/android/JsonTest.java deleted file mode 100644 index 901df126a..000000000 --- a/library/src/androidTest/java/com/qiniu/android/JsonTest.java +++ /dev/null @@ -1,112 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; - -import com.qiniu.android.utils.Json; - -import junit.framework.Assert; - -import org.json.JSONException; -import org.json.JSONObject; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * Created by Simon on 3/3/16. - */ -public class JsonTest extends AndroidTestCase { - - private boolean showContent = false; - - public void testEmpty() { - JSONObject json = new JSONObject(); - Assert.assertNotNull(json); - Assert.assertEquals("{}", json.toString()); - } - - // e: org.json.JSONException: End of input at character 0 of - public void testEmpty1() throws JSONException { - String str = ""; - Exception ex = null; - try { - JSONObject json = new JSONObject(str); - } catch (JSONException e) { - ex = e; - } - Assert.assertNotNull(ex); - if (showContent) { - Assert.assertEquals(str, ex.getMessage()); - } - } - - //e: org.json.JSONException: End of input at character 2 of - public void testEmpty2() throws JSONException { - String str = " "; - Exception ex = null; - try { - JSONObject json = new JSONObject(str); - } catch (JSONException e) { - ex = e; - } - Assert.assertNotNull(ex); - if (showContent) { - Assert.assertEquals(str, ex.getMessage()); - } - } - - public void testB() throws JSONException { - String str = "{}"; - JSONObject json = new JSONObject(str); - Assert.assertNotNull(json); - if (showContent) { - Assert.assertEquals(str, json.toString()); - } - } - - // e: org.json.JSONException: Value [] of type org.json.JSONArray cannot be converted to JSONObject - public void testArray() throws JSONException { - String str = "[]"; - Exception ex = null; - try { - JSONObject json = new JSONObject(str);// should JSONArray - } catch (JSONException e) { - ex = e; - } - Assert.assertNotNull(ex); - if (showContent) { - Assert.assertEquals(str, ex.getMessage()); - } - } - - //e: org.json.JSONException: Value null of type org.json.JSONObject$1 cannot be converted to JSONObject - public void testNull() throws JSONException { - String str = "null"; - Exception ex = null; - try { - JSONObject json = new JSONObject(str); - } catch (JSONException e) { - ex = e; - } - Assert.assertNotNull(ex); - if (showContent) { - Assert.assertEquals(str, ex.getMessage()); - } - } - - public void testEncodeMap() { - Map m = new HashMap<>(); - m.put("a", 1); - String s = Json.encodeMap(m); - Assert.assertEquals("{\"a\":1}", s); - } - - public void testEncodeList() { - List l = new ArrayList<>(); - l.add("a"); - String s = Json.encodeList(l); - Assert.assertEquals("[\"a\"]", s); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ListVectorTest.java b/library/src/androidTest/java/com/qiniu/android/ListVectorTest.java deleted file mode 100644 index 3210ad0e3..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ListVectorTest.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.ListVector; - -import junit.framework.Assert; - -import java.util.List; - -public class ListVectorTest extends BaseTest { - - public void testVectorList() { - - final int count = 1000; - final ListVector v = new ListVector<>(); - - new Thread(new Runnable() { - @Override - public void run() { - while (v.size() < count) { - vectorAdd(v); - } - } - }).start(); - - while (v.size() < count) { - vectorList(v); - } - - Assert.assertTrue("v:" + v, v.size() == count); - } - - public void testVectorSubList() { - - final int count = 1000; - final ListVector listVector = new ListVector<>(); - - while (listVector.size() < count) { - vectorAdd(listVector); - } - - final ListVector v = listVector.subList(0, count/2); - - new Thread(new Runnable() { - @Override - public void run() { - while (v.size() < count) { - vectorAdd(v); - } - } - }).start(); - - - while (v.size() < count) { - vectorList(v); - } - - Assert.assertTrue("v:" + v, v.size() == count); - } - - private void vectorAdd(List v) { - String e = v.size() + ""; - v.add(e); - System.out.println("add e:" + e); - } - - private void vectorList(ListVector v) { - final int size = v.size(); - v.enumerateObjects(new ListVector.EnumeratorHandler() { - @Override - public boolean enumerate(String s) { - System.out.println("size:" + size + " value:" + s); - return false; - } - }); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/LogUtilsTest.java b/library/src/androidTest/java/com/qiniu/android/LogUtilsTest.java deleted file mode 100644 index 926ae7d99..000000000 --- a/library/src/androidTest/java/com/qiniu/android/LogUtilsTest.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.qiniu.android; - -import android.util.Log; - -import com.qiniu.android.utils.LogUtil; - -public class LogUtilsTest extends BaseTest { - - public void testLog() { - - LogUtil.enableLog(true); - LogUtil.setLogLevel(Log.VERBOSE); - - Throwable throwable = new Throwable(); - - assertTrue(validLogCode(LogUtil.v("log"))); - assertTrue(validLogCode(LogUtil.v("v", "log"))); - assertTrue(validLogCode(LogUtil.v("v", "log", null))); - assertTrue(validLogCode(LogUtil.v("v", "log", throwable))); - - assertTrue(validLogCode(LogUtil.d("log"))); - assertTrue(validLogCode(LogUtil.d("v", "log"))); - assertTrue(validLogCode(LogUtil.d("v", "log", null))); - assertTrue(validLogCode(LogUtil.d("v", "log", throwable))); - - assertTrue(validLogCode(LogUtil.i("log"))); - assertTrue(validLogCode(LogUtil.i("v", "log"))); - assertTrue(validLogCode(LogUtil.i("v", "log", null))); - assertTrue(validLogCode(LogUtil.i("v", "log", throwable))); - - assertTrue(validLogCode(LogUtil.w("log"))); - assertTrue(validLogCode(LogUtil.w("v", "log"))); - assertTrue(validLogCode(LogUtil.w("v", "log", null))); - assertTrue(validLogCode(LogUtil.w("v", "log", throwable))); - - assertTrue(validLogCode(LogUtil.e("log"))); - assertTrue(validLogCode(LogUtil.e("v", "log"))); - assertTrue(validLogCode(LogUtil.e("v", "log", null))); - assertTrue(validLogCode(LogUtil.e("v", "log", throwable))); - - LogUtil.enableLog(false); - } - - private boolean validLogCode(int code) { - return !(code == -10000 || code == -10001); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/NetworkTest.java b/library/src/androidTest/java/com/qiniu/android/NetworkTest.java deleted file mode 100644 index e75bc5d98..000000000 --- a/library/src/androidTest/java/com/qiniu/android/NetworkTest.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.AndroidNetwork; - -import junit.framework.TestCase; - -/** - * Created by bailong on 16/9/7. - */ -public class NetworkTest extends TestCase { - public void testConnected() { - boolean stat = AndroidNetwork.isNetWorkReady(); - assertTrue(stat); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/PipelineTest.java b/library/src/androidTest/java/com/qiniu/android/PipelineTest.java deleted file mode 100644 index 61cd11378..000000000 --- a/library/src/androidTest/java/com/qiniu/android/PipelineTest.java +++ /dev/null @@ -1,173 +0,0 @@ -package com.qiniu.android; - - -import android.test.InstrumentationTestCase; - -import com.qiniu.android.bigdata.pipeline.Pipeline; -import com.qiniu.android.bigdata.pipeline.Points; -import com.qiniu.android.http.ResponseInfo; - -import junit.framework.Assert; - -import java.util.ArrayList; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; - -/** - * Created by long on 2017/7/25. - */ - -public class PipelineTest extends InstrumentationTestCase { - final CountDownLatch signal = new CountDownLatch(1); - private volatile ResponseInfo info = null; - - public void testPoint() { - StringBuilder b1 = new StringBuilder(); - Points.formatPoint(new A(3), b1); - StringBuilder b2 = new StringBuilder(); - Map m = new HashMap<>(); - m.put("a", 3); - Points.formatPoint(m, b2); - Assert.assertEquals(b1.toString(), b2.toString()); - } - - public void testPump() { - Map map = new HashMap<>(); - map.put("platform", "android"); - map.put("tl", 1L); - map.put("tf", 1.0); - map.put("tb", true); - map.put("td", new Date()); - Pipeline pipe = new Pipeline(null); - pipe.pump("testsdk", map, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { - @Override - public void complete(ResponseInfo inf) { - info = inf; - signal.countDown(); - } - }); - - try { - signal.await(1200, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", info); - } catch (InterruptedException e) { - e.printStackTrace(); - } - System.out.println(info); -// Assert.assertTrue(info.isOK()); - } - - public void testPump2() { - Pipeline pipe = new Pipeline(null); - pipe.pump("testsdk", new tsdk(), "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { - @Override - public void complete(ResponseInfo inf) { - info = inf; - signal.countDown(); - } - }); - - try { - signal.await(1200, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", info); - } catch (InterruptedException e) { - e.printStackTrace(); - } -// Assert.assertTrue(info.isOK()); - } - - public void testPump3() { - Map map = new HashMap<>(); - map.put("platform", "android"); - map.put("tl", 1L); - map.put("tf", 1.0); - map.put("tb", true); - map.put("td", new Date()); - Pipeline pipe = new Pipeline(null); - List> list = new ArrayList<>(); - list.add(map); - list.add(map); - pipe.pumpMulti("testsdk", list, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { - @Override - public void complete(ResponseInfo inf) { - info = inf; - signal.countDown(); - } - }); - - try { - signal.await(1200, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", info); - } catch (InterruptedException e) { - e.printStackTrace(); - } - System.out.println(info); -// Assert.assertTrue(info.isOK()); - } - - public void testPump4() { - Pipeline pipe = new Pipeline(null); - List list = new ArrayList<>(); - list.add(new tsdk()); - list.add(new tsdk()); - pipe.pumpMultiObjects("testsdk", list, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { - @Override - public void complete(ResponseInfo inf) { - info = inf; - signal.countDown(); - } - }); - - try { - signal.await(1200, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", info); - } catch (InterruptedException e) { - e.printStackTrace(); - } -// Assert.assertTrue(info.isOK()); - } - - public void testPump5() { - Pipeline pipe = new Pipeline(null); - tsdk[] t = new tsdk[2]; - t[0] = new tsdk(); - t[1] = new tsdk(); - pipe.pumpMultiObjects("testsdk", t, "Pandora le0xKwjp2_9ZGZMkCok7Gko6aG5GnIHValG82deI:yIl-J0zNjJCUii_7jag6-U79DPY=:eyJyZXNvdXJjZSI6Ii92Mi9yZXBvcy90ZXN0c2RrL2RhdGEiLCJleHBpcmVzIjo1MTAxMDQ1Njg0LCJjb250ZW50TUQ1IjoiIiwiY29udGVudFR5cGUiOiJ0ZXh0L3BsYWluIiwiaGVhZGVycyI6IiIsIm1ldGhvZCI6IlBPU1QifQ==", new Pipeline.PumpCompleteHandler() { - @Override - public void complete(ResponseInfo inf) { - info = inf; - signal.countDown(); - } - }); - - try { - signal.await(1200, TimeUnit.SECONDS); // wait for callback - Assert.assertNotNull("timeout", info); - } catch (InterruptedException e) { - e.printStackTrace(); - } -// Assert.assertTrue(info.isOK()); - } - - static class A { - public Integer a; - - A(int i) { - a = i; - } - } - - static class tsdk { - public String platform = "android2"; - public long tl = 2; - public double tf = 2.0; - public boolean tb = true; - public Date td = new Date(); - - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/RequestTransactionTest.java b/library/src/androidTest/java/com/qiniu/android/RequestTransactionTest.java deleted file mode 100644 index ada5d55f6..000000000 --- a/library/src/androidTest/java/com/qiniu/android/RequestTransactionTest.java +++ /dev/null @@ -1,192 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.http.request.RequestTransaction; -import com.qiniu.android.http.request.handler.RequestProgressHandler; -import com.qiniu.android.http.metrics.UploadRegionRequestMetrics; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpToken; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.utils.LogUtil; - -import junit.framework.Assert; - -import org.json.JSONException; -import org.json.JSONObject; - -import java.util.ArrayList; - - -public class RequestTransactionTest extends BaseTest { - - public void testUCQuery(){ - - UpToken token = UpToken.parse(TestConfig.token_z0); - - ArrayList hosts = new ArrayList(); - hosts.add("uc.qbox.me"); - - final WaitCondition waitCondition = new WaitCondition(); - - RequestTransaction requestTransaction = new RequestTransaction(hosts, token); - requestTransaction.queryUploadHosts(true, new RequestTransaction.RequestCompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - Assert.assertTrue("pass", responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - public void testUploadForm(){ - - final WaitCondition waitCondition = new WaitCondition(); - - UpToken token = UpToken.parse(TestConfig.token_z0); - - ArrayList hosts = new ArrayList(); - hosts.add("upload.qiniup.com"); - - byte[] data = "你好".getBytes(); - RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), - UploadOptions.defaultOptions(), - hosts, null, - "android-transaction-form", - token); - requestTransaction.uploadFormData(data, null, true, new RequestProgressHandler() { - @Override - public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { - LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); - } - }, new RequestTransaction.RequestCompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - Assert.assertTrue("pass", responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - - public void testUploadBlock(){ - - final WaitCondition waitCondition = new WaitCondition(); - - makeBlock(new RequestTransaction.RequestCompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - - if (responseInfo.isOK()){ - - String ct = null; - try { - ct = response.getString("ctx"); - } catch (JSONException e) {} - - if (ct == null) { - Assert.assertTrue("pass", false); - waitCondition.shouldWait = false; - return; - } - - uploadChunk(ct, new RequestTransaction.RequestCompleteHandler(){ - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - - if (responseInfo.isOK()){ - - String ct_02 = null; - try { - ct_02 = response.getString("ctx"); - } catch (JSONException e) {} - - if (ct_02 == null) { - Assert.assertTrue("pass", false); - waitCondition.shouldWait = false; - return; - } - - makeFile(new String[]{ct_02}, new RequestTransaction.RequestCompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - Assert.assertTrue("pass", responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - } else { - Assert.assertTrue("pass", false); - waitCondition.shouldWait = false; - } - } - }); - } else { - Assert.fail("fail"); - waitCondition.shouldWait = false; - } - } - }); - - wait(waitCondition, 60); - } - - private void makeBlock(RequestTransaction.RequestCompleteHandler completeHandler){ - UpToken token = UpToken.parse(TestConfig.token_z0); - - ArrayList hosts = new ArrayList(); - hosts.add("upload.qiniup.com"); - - byte[] data = new byte[2*1024*1024]; - RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts, null, "android-transaction-block", token); - requestTransaction.makeBlock(0, 3*1024*1024, data, true, new RequestProgressHandler() { - @Override - public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { - LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); - } - }, completeHandler); - } - - private void uploadChunk(String ct, RequestTransaction.RequestCompleteHandler completeHandler){ - UpToken token = UpToken.parse(TestConfig.token_z0); - - ArrayList hosts = new ArrayList(); - hosts.add("upload.qiniup.com"); - - byte[] data = new byte[1*1024*1024]; - RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts, null,"android-transaction-block", token); - requestTransaction.uploadChunk(ct,0, data, 2*1024*1024,true, new RequestProgressHandler() { - @Override - public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { - LogUtil.i(("== progress: " + (totalBytesWritten*1.0/totalBytesExpectedToWrite))); - } - }, completeHandler); - } - - private void makeFile(String[] blockContexts, RequestTransaction.RequestCompleteHandler completeHandler){ - UpToken token = UpToken.parse(TestConfig.token_z0); - - ArrayList hosts = new ArrayList(); - hosts.add("upload.qiniup.com"); - - RequestTransaction requestTransaction = new RequestTransaction(new Configuration.Builder().build(), UploadOptions.defaultOptions(), hosts,null, "android-transaction-block", token); - requestTransaction.makeFile(3*1024*1024, "android-transaction-block-fileName", blockContexts, true, completeHandler); - } - - - public void testMakeFileError(){ - final WaitCondition waitCondition = new WaitCondition(); - - makeFile(null, new RequestTransaction.RequestCompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { - Assert.assertTrue("pass", !responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ResponseInfoTest.java b/library/src/androidTest/java/com/qiniu/android/ResponseInfoTest.java deleted file mode 100644 index 328876898..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ResponseInfoTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; - -public class ResponseInfoTest extends BaseTest { - - public void testCreate(){ - - ResponseInfo responseInfo = null; - - responseInfo = ResponseInfo.zeroSize(""); - assertTrue(responseInfo.statusCode == ResponseInfo.ZeroSizeFile); - - responseInfo = ResponseInfo.cancelled(); - assertTrue(responseInfo.statusCode == ResponseInfo.Cancelled); - - responseInfo = ResponseInfo.invalidArgument(""); - assertTrue(responseInfo.statusCode == ResponseInfo.InvalidArgument); - - responseInfo = ResponseInfo.invalidToken(""); - assertTrue(responseInfo.statusCode == ResponseInfo.InvalidToken); - - responseInfo = ResponseInfo.fileError(null); - assertTrue(responseInfo.statusCode == ResponseInfo.InvalidFile); - - responseInfo = ResponseInfo.networkError(""); - assertTrue(responseInfo.statusCode == ResponseInfo.NetworkError); - assertTrue(responseInfo.isNetworkBroken()); - assertTrue(responseInfo.needRetry()); - - responseInfo = ResponseInfo.localIOError(""); - assertTrue(responseInfo.statusCode == ResponseInfo.LocalIOError); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/ResumeUploadTest.java b/library/src/androidTest/java/com/qiniu/android/ResumeUploadTest.java deleted file mode 100644 index 3baf32984..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ResumeUploadTest.java +++ /dev/null @@ -1,382 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UploadOptions; - -import java.io.File; -import java.io.IOException; -import java.util.HashMap; -import java.util.Map; - - -public class ResumeUploadTest extends UploadFlowTest { - - - public void testSwitchRegionV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - int[] sizeArray = {1000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_switch_region_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - switchRegionTestWithFile(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testCancelV1() { - float cancelPercent = (float) 0.5; - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - int[] sizeArray = {10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_cancel_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - cancelTest((long) (size * cancelPercent), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_http_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpsV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - int[] sizeArray = {500, 3000, 4000, 7000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_https_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testReuploadV1() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .chunkSize(1024 * 1024) - .build(); - int[] sizeArray = {30000}; - for (int size : sizeArray) { - String key = "android_resume_reupload_v1_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - reuploadUploadTest((long) (size * 0.5), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testNoKeyV1() { - int size = 600; - String key = "android_resume_no_key_v1_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); - - TempFile.remove(file); - } - - public void test0kV1() { - int size = 0; - String key = "android_resume_0k_v1_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); - - TempFile.remove(file); - } - - public void testCustomParamV1() { - - Map userParam = new HashMap<>(); - userParam.put("foo", "foo_value"); - userParam.put("bar", "bar_value"); - - Map metaParam = new HashMap<>(); - metaParam.put("0000", "meta_value_0"); - metaParam.put("x-qn-meta-aaa", "meta_value_1"); - metaParam.put("x-qn-meta-key-2", "meta_value_2"); - - UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); - - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V1) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - - String key = "android_resume_custom_param_v1"; - File file = null; - try { - file = TempFile.createFile(5 * 1024, key); - } catch (IOException e) { - e.printStackTrace(); - } - - uploadFileAndAssertSuccessResult(file, key, configuration, options); - } - - public void testSwitchRegionV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .chunkSize(4 * 1024 * 1024) - .useHttps(true) - .build(); - int[] sizeArray = {5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_switch_region_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - switchRegionTestWithFile(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testCancelV2() { - float cancelPercent = (float) 0.5; - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .chunkSize(4 * 1024 * 1024) - .useHttps(true) - .build(); - int[] sizeArray = {10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_cancel_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - cancelTest((long) (size * cancelPercent), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .chunkSize(4 * 1024 * 1024) - .useHttps(false) - .build(); - int[] sizeArray = {500, 1000, 3000, 4000, 5000, 8000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_http_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testHttpsV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .chunkSize(4 * 1024 * 1024) - .useHttps(true) - .build(); - int[] sizeArray = {500, 3000, 4000, 7000, 10000, 20000}; - for (int size : sizeArray) { - String key = "android_resume_https_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - uploadFileAndAssertSuccessResult(file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testReuploadV2() { - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .useHttps(true) - .chunkSize(4 * 1024 * 1024) - .build(); - int[] sizeArray = {30000}; - for (int size : sizeArray) { - String key = "android_resume_reupload_v2_" + size + "k"; - try { - File file = TempFile.createFile(size, key); - reuploadUploadTest((long) (size * 0.7), file, key, configuration, null); - TempFile.remove(file); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - - public void testNoKeyV2() { - int size = 600; - String key = "android_resume_reupload_v2_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - uploadFileAndAssertSuccessResult(file, null, configurationHttps, null); - - TempFile.remove(file); - } - - public void test0kV2() { - int size = 0; - String key = "android_resume_0k_v2_" + size + "k"; - File file = null; - try { - file = TempFile.createFile(size, key); - } catch (IOException e) { - e.printStackTrace(); - } - - Configuration configurationHttp = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .useHttps(false) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttp, null); - - Configuration configurationHttps = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .useHttps(true) - .build(); - uploadFileAndAssertResult(ResponseInfo.ZeroSizeFile, file, key, configurationHttps, null); - - TempFile.remove(file); - } - - public void testCustomParamV2() { - - Map userParam = new HashMap<>(); - userParam.put("foo", "foo_value"); - userParam.put("bar", "bar_value"); - - Map metaParam = new HashMap<>(); - metaParam.put("0000", "meta_value_0"); - metaParam.put("x-qn-meta-aaa", "meta_value_1"); - metaParam.put("x-qn-meta-key-2", "meta_value_2"); - - UploadOptions options = new UploadOptions(userParam, metaParam, null, true, null, null, null); - - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) - .useConcurrentResumeUpload(false) - .chunkSize(4 * 1024 * 1024) - .useHttps(false) - .build(); - - String key = "android_resume_custom_param_v2"; - File file = null; - try { - file = TempFile.createFile(5 * 1024, key); - } catch (IOException e) { - e.printStackTrace(); - } - - uploadFileAndAssertSuccessResult(file, key, configuration, options); - } -} \ No newline at end of file diff --git a/library/src/androidTest/java/com/qiniu/android/RetryTest.java b/library/src/androidTest/java/com/qiniu/android/RetryTest.java deleted file mode 100644 index 4d9c0c65c..000000000 --- a/library/src/androidTest/java/com/qiniu/android/RetryTest.java +++ /dev/null @@ -1,207 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.common.Zone; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UpProgressHandler; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.utils.LogUtil; - -import org.json.JSONObject; - -import java.io.File; - -/** - * Created by yangsen on 2020/6/3 - */ -public class RetryTest extends BaseTest { - - - public void testUpload() { - - final TestParam param = new TestParam(); - param.count = 10; - - for (int i = 0; i < param.count; i++) { - - final int i_p = i; - - new Thread(new Runnable() { - @Override - public void run() { - - try { - template((i_p + 1), true, new CompleteHandler() { - @Override - public void complete(boolean isSuccess) { - - synchronized (this){ - if (isSuccess){ - param.successCount += 1; - } - param.completeCount += 1; - } - - } - }); - } catch (Throwable ignored) { - } - - } - }).start(); - - try { - Thread.sleep(2000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (param.completeCount != param.count){ - return true; - } else { - return false; - } - } - }, 600 * 10); - - assertTrue((param.completeCount == param.successCount)); - } - - public void testUploadError(){ - final TestParam param = new TestParam(); - param.count = 10; - - for (int i = 0; i < param.count; i++) { - - final int i_p = i; - - new Thread(new Runnable() { - @Override - public void run() { - - try { - template((i_p + 1), false, new CompleteHandler() { - @Override - public void complete(boolean isSuccess) { - - synchronized (this){ - if (isSuccess){ - param.successCount += 1; - } - param.completeCount += 1; - } - - } - }); - } catch (Throwable ignored) { - } - - } - }).start(); - - try { - Thread.sleep(2000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (param.completeCount != param.count){ - return true; - } else { - return false; - } - } - }, 600 * 10); - - assertTrue((param.successCount == 0)); - } - - private void template(int size, boolean hasValidHost, final CompleteHandler completeHandler) throws Throwable{ - - final WaitCondition waitCondition = new WaitCondition(); - - final String expectKey = "android-retry-" + size + "k"; - final File f = TempFile.createFile(size); - String[] s = null; - if (hasValidHost){ - s = new String[]{"uptemp01.qbox.me", "uptemp02.qbox.me", - "uptemp03.qbox.me", "uptemp04.qbox.me", - "uptemp05.qbox.me", "uptemp06.qbox.me", - "uptemp07.qbox.me", "uptemp08.qbox.me", - "uptemp09.qbox.me", "uptemp10.qbox.me", - "uptemp11.qbox.me", "uptemp12.qbox.me", - "uptemp13.qbox.me", "uptemp14.qbox.me", - "upload-na0.qbox.me", "up-na0.qbox.me"}; - } else { - s = new String[]{"uptemp01.qbox.me", "uptemp02.qbox.me", - "uptemp03.qbox.me", "uptemp04.qbox.me", - "uptemp05.qbox.me", "uptemp06.qbox.me", - "uptemp07.qbox.me", "uptemp08.qbox.me", - "uptemp09.qbox.me", "uptemp10.qbox.me", - "uptemp11.qbox.me", "uptemp12.qbox.me", - "uptemp13.qbox.me", "uptemp14.qbox.me"}; - } - - Zone z = new FixedZone(s); - Configuration c = new Configuration.Builder() - .zone(z).useHttps(true).useConcurrentResumeUpload(false) - .build(); - UploadManager uploadManager = new UploadManager(c); - final UploadOptions options = new UploadOptions(null, null, true, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - LogUtil.i(("progress:" + percent)); - } - }, null); - uploadManager.put(f, expectKey, TestConfig.token_na0, new UpCompletionHandler() { - - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - - if (rinfo.isOK() && rinfo.reqId.length() > 0 - && expectKey.equals(k)){ - - completeHandler.complete(true); -// try { -// String etag_file = Etag.file(f); -// String etag_server = response.getString("hash"); -// if (etag_file.equals(etag_server)){ -// completeHandler.complete(true); -// } else { -// completeHandler.complete(false); -// } -// } catch (IOException ignored) { -// } catch (JSONException ignored) { -// } - } else { - completeHandler.complete(false); - } - - waitCondition.shouldWait = false; - } - }, options); - - wait(waitCondition, 60); - } - - private static class TestParam{ - int count = 100; - int successCount = 0; - int completeCount = 0; - } - - private interface CompleteHandler{ - void complete(boolean isSuccess); - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/ServerConfigTest.java b/library/src/androidTest/java/com/qiniu/android/ServerConfigTest.java deleted file mode 100644 index f1b15653b..000000000 --- a/library/src/androidTest/java/com/qiniu/android/ServerConfigTest.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.storage.serverConfig.ServerConfig; -import com.qiniu.android.storage.serverConfig.ServerConfigMonitor; -import com.qiniu.android.storage.serverConfig.ServerUserConfig; - -import org.json.JSONException; -import org.json.JSONObject; - -public class ServerConfigTest extends BaseTest { - - public void testMonitor() { - ServerConfigMonitor.removeConfigCache(); - ServerConfigMonitor.startMonitor(); - ServerConfigMonitor.setToken(TestConfig.token_na0); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return true; - } - }, 30); - } - - public void testServerConfigModel() { - String serverConfigJsonString = "{\"region\":{\"clear_id\":10,\"clear_cache\":true},\"dns\":{\"enabled\":true,\"clear_id\":10,\"clear_cache\":true,\"doh\":{\"enabled\":true,\"ipv4\":{\"override_default\":true,\"urls\":[\"https://223.5.5.5/dns-query\"]},\"ipv6\":{\"override_default\":true,\"urls\":[\"https://FFAE::EEEE/dns-query\"]}},\"udp\":{\"enabled\":true,\"ipv4\":{\"ips\":[\"223.5.5.5\",\"1.1.1.1\"],\"override_default\":true},\"ipv6\":{\"ips\":[\"FFAE::EEEE\"],\"override_default\":true}}},\"ttl\":86400}"; - try { - JSONObject jsonObject = new JSONObject(serverConfigJsonString); - ServerConfig serverConfig = new ServerConfig(jsonObject); - assertTrue("server config ttl was err", serverConfig.isValid()); - assertTrue("server config dns was null", serverConfig.getDnsConfig() != null); - assertTrue("server config dns enable was null", serverConfig.getDnsConfig().getEnable() != null); - assertTrue("server config dns clear id was null", serverConfig.getDnsConfig().getClearId() > 0); - assertTrue("server config dns udp was null", serverConfig.getDnsConfig().getUdpDnsConfig() != null); - assertTrue("server config dns udp enable was null", serverConfig.getDnsConfig().getUdpDnsConfig().getEnable() != null); - assertTrue("server config dns udp ipv4 server was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server() != null); - assertTrue("server config dns udp ipv4 server isOverride was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server().getIsOverride()); - assertTrue("server config dns udp ipv4 server servers was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv4Server().getServers() != null); - assertTrue("server config dns udp ipv6 server was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server() != null); - assertTrue("server config dns udp ipv6 server isOverride was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server().getIsOverride()); - assertTrue("server config dns udp ipv6 server servers was null", serverConfig.getDnsConfig().getUdpDnsConfig().getIpv6Server().getServers() != null); - assertTrue("server config dns doh was null", serverConfig.getDnsConfig().getDohDnsConfig() != null); - assertTrue("server config dns doh enable was null", serverConfig.getDnsConfig().getDohDnsConfig().getEnable() != null); - assertTrue("server config dns doh ipv4 server was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server() != null); - assertTrue("server config dns doh ipv4 server isOverride was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server().getIsOverride()); - assertTrue("server config dns doh ipv4 server servers was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv4Server().getServers() != null); - assertTrue("server config dns doh ipv6 server was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server() != null); - assertTrue("server config dns doh ipv6 server isOverride was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server().getIsOverride()); - assertTrue("server config dns doh ipv6 server servers was null", serverConfig.getDnsConfig().getDohDnsConfig().getIpv6Server().getServers() != null); - assertTrue("server config region was null", serverConfig.getRegionConfig() != null); - assertTrue("server config region clear id was null", serverConfig.getRegionConfig().getClearId() > 0); - } catch (JSONException e) { - fail("server config exception:" + e); - } - - String serverUserConfigJsonString = "{\"ttl\":86400,\"http3\":{\"enabled\":true},\"network_check\":{\"enabled\":true}}"; - try { - JSONObject jsonObject = new JSONObject(serverUserConfigJsonString); - ServerUserConfig serverUserConfig = new ServerUserConfig(jsonObject); - assertTrue("server user config ttl was error", serverUserConfig.isValid()); - assertTrue("server user config http3 enable was null", serverUserConfig.getHttp3Enable() != null); - assertTrue("server user config network check enable id was null", serverUserConfig.getNetworkCheckEnable()); - } catch (JSONException e) { - fail("server config exception:" + e); - } - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/SingleFlightTest.java b/library/src/androidTest/java/com/qiniu/android/SingleFlightTest.java deleted file mode 100644 index cea74bb71..000000000 --- a/library/src/androidTest/java/com/qiniu/android/SingleFlightTest.java +++ /dev/null @@ -1,188 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.LogUtil; -import com.qiniu.android.utils.SingleFlight; - -public class SingleFlightTest extends BaseTest { - - private static final int RetryCount = 5; - - public void testSync() { - final TestStatus testStatus = new TestStatus(); - testStatus.maxCount = 1000; - testStatus.completeCount = 0; - - SingleFlight singleFlight = new SingleFlight(); - for (int i = 0; i < testStatus.maxCount; i++) { - singleFlightPerform(singleFlight, i, RetryCount, false, new CompleteHandler() { - @Override - public void complete() throws Exception { - testStatus.completeCount += 1; - LogUtil.d("== sync completeCount:" + testStatus.completeCount); - } - }); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return testStatus.maxCount != testStatus.completeCount; - } - }, 60); - } - - public void testSyncRetry() { - final TestStatus testStatus = new TestStatus(); - testStatus.maxCount = 1000; - testStatus.completeCount = 0; - - SingleFlight singleFlight = new SingleFlight(); - for (int i = 0; i < testStatus.maxCount; i++) { - singleFlightPerform(singleFlight, i, 0, false, new CompleteHandler() { - @Override - public void complete() throws Exception { - testStatus.completeCount += 1; - LogUtil.d("== sync completeCount:" + testStatus.completeCount); - } - }); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return testStatus.maxCount != testStatus.completeCount; - } - }, 60); - } - - public void testAsync() { - final TestStatus testStatus = new TestStatus(); - testStatus.maxCount = 1000; - testStatus.completeCount = 0; - - SingleFlight singleFlight = new SingleFlight(); - for (int i = 0; i < testStatus.maxCount; i++) { - singleFlightPerform(singleFlight, i, RetryCount, true, new CompleteHandler() { - @Override - public void complete() throws Exception { - synchronized (testStatus) { - testStatus.completeCount += 1; - } - LogUtil.d("== async complete Count:" + testStatus.completeCount); - } - }); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return testStatus.maxCount != testStatus.completeCount; - } - }, 60); - - assertTrue("== async" + "max Count:" + testStatus.maxCount + " complete Count:" + testStatus.completeCount, testStatus.maxCount == testStatus.completeCount); - LogUtil.d("== async" + "max Count:" + testStatus.maxCount + " complete Count:" + testStatus.completeCount); - } - - public void testAsyncRetry() { - final TestStatus testStatus = new TestStatus(); - testStatus.maxCount = 1000; - testStatus.completeCount = 0; - - SingleFlight singleFlight = new SingleFlight(); - for (int i = 0; i < testStatus.maxCount; i++) { - singleFlightPerform(singleFlight, i, 0, true, new CompleteHandler() { - @Override - public void complete() throws Exception { - synchronized (testStatus) { - testStatus.completeCount += 1; - } - LogUtil.d("== async completeCount:" + testStatus.completeCount); - } - }); - } - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return testStatus.maxCount != testStatus.completeCount; - } - }, 60); - - LogUtil.d("== async completeCount:" + testStatus.completeCount + " end"); - } - - private void singleFlightPerform(final SingleFlight singleFlight, - final int index, - final int retryCount, - final boolean isAsync, - final CompleteHandler completeHandler) { - - try { - singleFlight.perform("key", new SingleFlight.ActionHandler() { - @Override - public void action(final SingleFlight.CompleteHandler singleFlightCompleteHandler) throws Exception { - - final CompleteHandler completeHandlerP = new CompleteHandler() { - @Override - public void complete() throws Exception { - if (retryCount < RetryCount) { - LogUtil.d("== " + (isAsync ? "async" : "sync") + " action retryCount:" + retryCount + " index:" + index + " error"); - throw new Exception("== 123 =="); - } else { - LogUtil.d("== " + (isAsync ? "async" : "sync") + " action retryCount:" + retryCount + " index:" + index + " value"); - singleFlightCompleteHandler.complete(index + ""); - } - } - }; - - if (isAsync) { - new Thread(new Runnable() { - @Override - public void run() { - try { - completeHandlerP.complete(); - } catch (Exception e) { - singleFlightCompleteHandler.complete(null); - } - } - }).start(); - } else { - completeHandlerP.complete(); - } - } - }, new SingleFlight.CompleteHandler() { - @Override - public void complete(Object value) { - if (retryCount < RetryCount) { - singleFlightPerform(singleFlight, index, retryCount + 1, isAsync, completeHandler); - } else { - LogUtil.d("== " + (isAsync ? "async" : "sync") + " action complete retryCount:" + retryCount + " value:" + value + " index:" + index); - if (!isAsync) { - assertTrue("index:" + index + "value error",(value + "").equals(index + "")); - } - try { - completeHandler.complete(); - } catch (Exception e) { - } - } - } - }); - } catch (Exception e) { - singleFlightPerform(singleFlight, index, retryCount + 1, isAsync, completeHandler); - } - } - - - - private interface CompleteHandler { - void complete() throws Exception; - } - - - protected static class TestStatus { - int maxCount; - int completeCount; - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/StringUtilsTest.java b/library/src/androidTest/java/com/qiniu/android/StringUtilsTest.java deleted file mode 100644 index 95d1cdc00..000000000 --- a/library/src/androidTest/java/com/qiniu/android/StringUtilsTest.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.StringUtils; - -public class StringUtilsTest extends BaseTest { - - public void testJoin(){ - - String string = ""; - - string = StringUtils.join(new String[]{"1", "2"}, "-"); - assertTrue(string.equals("1-2")); - - string = StringUtils.jsonJoin(new String[]{"1", "2"}); - assertTrue(string.equals("\"1\",\"2\"")); - - } - - public void testTransform(){ - - String string = ""; - - string = StringUtils.jsonJoin(new Long[]{1L, 2L}); - assertTrue(string.equals("\"1\",\"2\"")); - - String[] stringArray = StringUtils.longToString(new Long[]{1L, 2L}); - assertTrue(stringArray.length == 2); - - string = "1234"; - byte[] data = StringUtils.toByteArray(string); - byte[] dataR = new byte[]{-84, -19, 0, 5, 116, 0, 4, 49, 50, 51, 52}; - assertTrue(new String(dataR).equals(new String(data))); - - Object stringR = StringUtils.toObject(dataR); - assertTrue(stringR.equals(string)); - - - string = "tom"; - string = StringUtils.upperCase(string); - assertTrue(string.equals("Tom")); - } - - - public void testToken(){ - String token = "jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu:mWEhowqz4sG301DXU6CB3IO7Zss=:eyJzY29wZSI6InpvbmUxLXNwYWNlIiwiZGVhZGxpbmUiOjE1OTczOTMzOTYsICJyZXR1cm5Cb2R5Ijoie1wiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; - String ak = StringUtils.getAkAndScope(token); - assertTrue(ak.equals("jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22euzone1-space")); - - String bucket = StringUtils.getBucket(token); - assertTrue(bucket.equals("zone1-space")); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/SyncFormUploadTest.java b/library/src/androidTest/java/com/qiniu/android/SyncFormUploadTest.java deleted file mode 100644 index acbee9ad9..000000000 --- a/library/src/androidTest/java/com/qiniu/android/SyncFormUploadTest.java +++ /dev/null @@ -1,198 +0,0 @@ -package com.qiniu.android; - -import android.test.suitebuilder.annotation.MediumTest; -import android.test.suitebuilder.annotation.SmallTest; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.common.Zone; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.utils.Etag; - -import junit.framework.Assert; - -import org.json.JSONObject; - -import java.io.File; -import java.util.HashMap; -import java.util.Map; - -public class SyncFormUploadTest extends BaseTest { - private UploadManager uploadManager; - private volatile String key; - private volatile ResponseInfo info; - private volatile JSONObject resp; - - public void setUp() { - uploadManager = new UploadManager(); - } - - @SmallTest - public void testHello() { - final String expectKey = "你好-testHello;\"\r\n\r\n\r\n"; - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - byte[] b = "hello".getBytes(); - info = uploadManager.syncPut(b, expectKey, TestConfig.commonToken, opt); - resp = info.response; - - Assert.assertTrue(info.toString(), info.isOK()); - Assert.assertNotNull(info.reqId); - Assert.assertNotNull(resp); - - String hash = resp.optString("hash"); - Assert.assertEquals(hash, Etag.data(b)); - Assert.assertEquals(expectKey, key = resp.optString("key")); - } - - @SmallTest - public void test0Data(){ - final String expectKey = "你好-test0Data;\"\r\n\r\n\r\n"; - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - - info = uploadManager.syncPut("".getBytes(), expectKey, TestConfig.commonToken, opt); - resp = info.response; - - assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); - assertNull(resp); - } - - @SmallTest - public void testNoKey() { - final String expectKey = null; - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - info = uploadManager.syncPut("hello".getBytes(), expectKey, TestConfig.commonToken, opt); - - resp = info.response; - key = resp.optString("key"); - Assert.assertTrue(info.toString(), info.isOK()); - - Assert.assertNotNull(info.reqId); - Assert.assertNotNull(resp); - Assert.assertEquals("Fqr0xh3cxeii2r7eDztILNmuqUNN", resp.optString("key", "")); - } - - @SmallTest - public void testInvalidtoken_z0() { - final String expectKey = "你好-testInvalidtoken_z0"; - info = uploadManager.syncPut("hello".getBytes(), expectKey, "invalid", null); - - resp = info.response; - Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, info.statusCode); - assertNull(resp); - } - - @SmallTest - public void testNoData() { - final String expectKey = "你好-testNoData"; - - info = uploadManager.syncPut((byte[]) null, expectKey, "invalid", null); - - resp = info.response; - Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, - info.statusCode); - Assert.assertNull(resp); - } - - @SmallTest - public void testNotoken_z0() { - final String expectKey = "你好-testNotoken_z0"; - info = uploadManager.syncPut(new byte[1], expectKey, null, null); - - resp = info.response; - Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, info.statusCode); - Assert.assertNull(resp); - } - - @SmallTest - public void testEmptytoken_z0() { - final String expectKey = "你好-testEmptytoken_z0"; - info = uploadManager.syncPut(new byte[1], expectKey, "", null); - - resp = info.response; - Assert.assertEquals(info.toString(), ResponseInfo.InvalidToken, - info.statusCode); - Assert.assertNull(resp); - } - - @MediumTest - public void testFile() throws Throwable { - final String expectKey = "世/界-testFile"; - final File f = TempFile.createFile(5*1024); - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - info = uploadManager.syncPut(f, expectKey, TestConfig.commonToken, opt); - - resp = info.response; - key = resp.optString("key"); - assertEquals(info.toString(), expectKey, key); - Assert.assertTrue(info.toString(), info.isOK()); - - //上传策略含空格 \"fname\":\" $(fname) \" -// assertEquals(f.getName(), resp.optString("fname", "res doesn't include the FNAME").trim()); - assertNotNull(info.reqId); - assertNotNull(resp); -// String hash = resp.getString("hash"); -// assertEquals(hash, Etag.file(f)); - TempFile.remove(f); - } - - @MediumTest - public void test0File() throws Throwable { - final String expectKey = "世/界-test0File"; - final File f = TempFile.createFile(0); - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - info = uploadManager.syncPut(f, expectKey, TestConfig.commonToken, opt); - - resp = info.response; - Assert.assertEquals(f.toString(), 0, f.length()); - Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); - Assert.assertNull(resp); - Assert.assertFalse(info.toString(), info.isOK()); - Assert.assertEquals(info.toString(), "", info.reqId); - TempFile.remove(f); - } - - @SmallTest - public void test0byte() { - info = uploadManager.syncPut(new byte[0], null, TestConfig.commonToken, null); - Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); - - info = uploadManager.syncPut("", null, TestConfig.commonToken, null); - Assert.assertEquals(info.toString(), ResponseInfo.ZeroSizeFile, info.statusCode); - } - - - @SmallTest - public void testHttps() { - final String expectKey = "你好-testHttps;\"\r\n\r\n\r\n"; - Map params = new HashMap(); - params.put("x:foo", "fooval"); - final UploadOptions opt = new UploadOptions(params, null, true, null, null); - String[] s = new String[]{"up-na0.qbox.me"}; - Zone z = new FixedZone(s); - Configuration c = new Configuration.Builder() - .zone(z) - .useHttps(true) - .build(); - UploadManager uploadManager2 = new UploadManager(c); - info = uploadManager2.syncPut("hello".getBytes(), expectKey, TestConfig.commonToken, opt); - - resp = info.response; - key = resp.optString("key"); - Assert.assertEquals(info.toString(), expectKey, key); - Assert.assertTrue(info.toString(), info.isOK()); - Assert.assertNotNull(info.reqId); - Assert.assertNotNull(resp); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/SystemDnsTest.java b/library/src/androidTest/java/com/qiniu/android/SystemDnsTest.java deleted file mode 100644 index 5b2a47a27..000000000 --- a/library/src/androidTest/java/com/qiniu/android/SystemDnsTest.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.dns.IDnsNetworkAddress; -import com.qiniu.android.http.dns.SystemDns; -import com.qiniu.android.utils.Utils; - -import java.net.UnknownHostException; -import java.util.List; - -public class SystemDnsTest extends BaseTest { - - public void testDnsLookup() { - SystemDns dns = new SystemDns(5); - try { - List result = dns.lookup("upload.qiniup.com"); - assertTrue("testDnsLookup fail:", result != null && result.size() > 0); - } catch (UnknownHostException e) { - e.printStackTrace(); - fail("testDnsLookup fail because:" + e.getMessage()); - } - } - - public void testDnsTimeout() { - long start = Utils.currentSecondTimestamp(); - int timeout = 5; - SystemDns dns = new SystemDns(timeout); - try { - List result = dns.lookup("a.a.a.cn"); - assertTrue("testDnsTimeout fail:", result == null || result.size() == 0); - } catch (UnknownHostException e) { - e.printStackTrace(); - } - long end = Utils.currentSecondTimestamp(); - assertTrue("testDnsTimeout fail because timeout to long", end <= (start + timeout + 1)); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/SystemHttpClientTest.java b/library/src/androidTest/java/com/qiniu/android/SystemHttpClientTest.java deleted file mode 100644 index 14729f403..000000000 --- a/library/src/androidTest/java/com/qiniu/android/SystemHttpClientTest.java +++ /dev/null @@ -1,111 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.http.request.Request; -import com.qiniu.android.http.request.IRequestClient; -import com.qiniu.android.http.request.httpclient.SystemHttpClient; -import com.qiniu.android.http.metrics.UploadSingleRequestMetrics; - -import org.json.JSONObject; - - -public class SystemHttpClientTest extends BaseTest { - - public void testGet() { - - final WaitCondition waitCondition = new WaitCondition(); - - Request request = new Request("https://uc.qbox.me/v3/query?ak=jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu&bucket=zone0-space", - null, null, null, 15); - - SystemHttpClient client = new SystemHttpClient(); - client.request(request, true, null, null, new IRequestClient.CompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { - assertTrue("pass", responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - public void testSyncGet() { - - final WaitCondition waitCondition = new WaitCondition(); - - Request request = new Request("https://uc.qbox.me/v3/query?ak=jH983zIUFIP1OVumiBVGeAfiLYJvwrF45S-t22eu&bucket=zone0-space", - null, null, null, 15); - - SystemHttpClient client = new SystemHttpClient(); - client.request(request, false, null, null, new IRequestClient.CompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { - assertTrue("pass", responseInfo.isOK()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - public void testPostRequest() { - - final WaitCondition waitCondition = new WaitCondition(); - - Request request = new Request("http://www.baidu.com/", - Request.HttpMethodPOST, null, "hello".getBytes(), 15); - - SystemHttpClient client = new SystemHttpClient(); - client.request(request, true, null, null, new IRequestClient.CompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { - - assertFalse("pass", responseInfo.isServerError()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - public void testSyncPostRequest() { - - final WaitCondition waitCondition = new WaitCondition(); - - Request request = new Request("http://www.baidu.com/", - Request.HttpMethodPOST, null, "hello".getBytes(), 15); - - SystemHttpClient client = new SystemHttpClient(); - client.request(request, false, null, null, new IRequestClient.CompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { - - assertFalse("pass", responseInfo.isServerError()); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } - - public void testPostRequestError() { - - final WaitCondition waitCondition = new WaitCondition(); - - Request request = new Request("http://www.baidu.com/", - Request.HttpMethodPOST, null, "hello".getBytes(), 15); - - SystemHttpClient client = new SystemHttpClient(); - client.request(null, true, null, null, new IRequestClient.CompleteHandler() { - @Override - public void complete(ResponseInfo responseInfo, UploadSingleRequestMetrics metrics, JSONObject response) { - - assertTrue("pass", responseInfo.statusCode == ResponseInfo.InvalidArgument); - waitCondition.shouldWait = false; - } - }); - - wait(waitCondition, 60); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/TestFileRecorder.java b/library/src/androidTest/java/com/qiniu/android/TestFileRecorder.java deleted file mode 100644 index f4921a8c1..000000000 --- a/library/src/androidTest/java/com/qiniu/android/TestFileRecorder.java +++ /dev/null @@ -1,229 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCancellationSignal; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UpProgressHandler; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.storage.FileRecorder; -import com.qiniu.android.utils.LogUtil; - -import org.json.JSONObject; - -import java.io.File; -import java.io.IOException; -import java.security.MessageDigest; -import java.util.Date; -import java.util.HashMap; -import java.util.Map; - -public class TestFileRecorder extends BaseTest { - private volatile boolean cancelled; - private volatile boolean failed; - private UploadManager uploadManager; - private Configuration config; - private volatile String key; - private volatile ResponseInfo info; - private volatile JSONObject resp; - private volatile UploadOptions options; - - // copy from FileRecorder. - private static String hash(String base) { - try { - MessageDigest digest = MessageDigest.getInstance("SHA-1"); - byte[] hash = digest.digest(base.getBytes()); - StringBuffer hexString = new StringBuffer(); - - for (int i = 0; i < hash.length; i++) { - hexString.append(Integer.toString((hash[i] & 0xff) + 0x100, 16).substring(1)); - } - return hexString.toString(); - } catch (Exception ex) { - ex.printStackTrace(); - } - return null; - } - - @Override - protected void setUp() throws Exception { - File f = File.createTempFile("qiniutest", "b"); - String folder = f.getParent(); - FileRecorder fr = new FileRecorder(folder); - config = new Configuration.Builder().connectTimeout(15000)/*.recorder(fr)*/.build(); - uploadManager = new UploadManager(config); - } - - private void template(final int size, final double pos) throws Throwable { - - info = null; - - final File tempFile = TempFile.createFile(size); - final String expectKey = "rc=" + size + "k"; - cancelled = false; - failed = false; - Map params = new HashMap(); - params.put("x:a", "test"); - params.put("x:b", "test2"); - options = new UploadOptions(params, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - if (percent >= pos) { - cancelled = true; - } - LogUtil.i("progress " + percent); - } - }, new UpCancellationSignal() { - @Override - public boolean isCancelled() { - return cancelled; - } - }); - - uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - LogUtil.i("Cancel:" + k + rinfo); - key = k; - info = rinfo; - resp = response; - } - }, options); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 600); - - assertEquals(info.toString(), expectKey, key); - assertTrue(info.toString(), info.isCancelled()); - assertNull(resp); - - info = null; - cancelled = false; - options = new UploadOptions(null, null, false, new UpProgressHandler() { - @Override - public void progress(String key, double percent) { - if (percent < pos - config.chunkSize / (size * 1024.0)) { - failed = true; - } - LogUtil.i("continue progress " + percent); - } - }, null); - - - uploadManager.put(tempFile, expectKey, TestConfig.commonToken, new UpCompletionHandler() { - public void complete(String k, ResponseInfo rinfo, JSONObject response) { - LogUtil.i("Continue" + k + rinfo); - key = k; - info = rinfo; - resp = response; - } - }, options); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - if (info == null) { - return true; - } else { - return false; - } - } - }, 60); - - assertEquals(info.toString(), expectKey, key); - assertTrue(info.toString(), info.isOK()); - assertNotNull(resp); - -// String hash = resp.getString("hash"); -// assertEquals(hash, Etag.file(tempFile)); - - TempFile.remove(tempFile); - } - - public void test_4M1K() throws Throwable { - template(4 * 1024 + 1, 0.5); - - } - - public void test5M() throws Throwable { - template(5 * 1024, 0.51); - } - - public void test_5M1K() throws Throwable { - template(5 * 1024 + 1, 0.5); - - } - - public void test8M() throws Throwable { - template(8 * 1024, 0.51); - } - - public void test_8M1K() throws Throwable { - template(8 * 1024 + 1, 0.5); - - } - - public void test10M() throws Throwable { - template(10 * 1024, 0.51); - } - - public void test_10M1K() throws Throwable { - template(10 * 1024 + 1, 0.5); - - } - - public void testLastModify() throws IOException { - File f = File.createTempFile("qiniutest", "b"); - String folder = f.getParent(); - FileRecorder fr = new FileRecorder(folder); - - String key = "test_profile_"; - byte[] data = new byte[3]; - data[0] = 'a'; - data[1] = '8'; - data[2] = 'b'; - - fr.set(key, data); - byte[] data2 = fr.get(key); - - File recorderFile = new File(folder, hash(key)); - - long m1 = recorderFile.lastModified(); - - assertEquals(3, data2.length); - assertEquals('8', data2[1]); - - recorderFile.setLastModified(new Date().getTime() - 1000 * 3600 * 48 + 2300); - data2 = fr.get(key); - assertEquals(3, data2.length); - assertEquals('8', data2[1]); - - // 让记录文件过期，两天 - recorderFile.setLastModified(new Date().getTime() - 1000 * 3600 * 48 - 2300); - - long m2 = recorderFile.lastModified(); - - // 过期后，记录数据作废 - byte[] data3 = fr.get(key); - - assertNull(data3); - assertTrue(m1 - m2 > 1000 * 3600 * 48 && m1 - m2 < 1000 * 3600 * 48 + 5500); - - try { - Thread.sleep(2300); - } catch (InterruptedException e) { - e.printStackTrace(); - } - fr.set(key, data); - long m4 = recorderFile.lastModified(); - assertTrue(m4 > m1); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/TokenTest.java b/library/src/androidTest/java/com/qiniu/android/TokenTest.java deleted file mode 100644 index ae2816469..000000000 --- a/library/src/androidTest/java/com/qiniu/android/TokenTest.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.qiniu.android; - -import android.test.AndroidTestCase; -import com.qiniu.android.storage.UpToken; - -import java.util.Date; - -/** - * Created by bailong on 15/6/1. - */ -public class TokenTest extends AndroidTestCase { - public void testRight() { - - UpToken t = UpToken.parse(TestConfig.commonToken); - - assertTrue(!UpToken.isInvalid(t)); - assertTrue("token isValidForDuration error", t.isValidForDuration(5*60)); - assertTrue("token isValidBeforeDate error", t.isValidBeforeDate(new Date())); - assertTrue(t.toString() != null); - assertNotSame(t, null); - } - - public void testEmpty() { - UpToken t = UpToken.parse(null); - assertEquals(t, null); - - t = UpToken.parse(""); - assertEquals(t, null); - - t = UpToken.parse("1:2:3"); - assertEquals(t, null); - } - - public void testReturnUrl() { - UpToken t = UpToken.parse("QWYn5TFQsLLU1pL5MFEmX3s5DmHdUThav9WyOWOm:1jLiztn4plVyeB8Hie1ryO5z9uo=:eyJzY29wZSI6InB5c2RrIiwiZGVhZGxpbmUiOjE0MzM0ODM5MzYsInJldHVyblVybCI6Imh0dHA6Ly8xMjcuMC4wLjEvIn0="); - assertTrue(t.hasReturnUrl()); - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadBaseTest.java b/library/src/androidTest/java/com/qiniu/android/UploadBaseTest.java deleted file mode 100644 index 5719fe7e2..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadBaseTest.java +++ /dev/null @@ -1,276 +0,0 @@ -package com.qiniu.android; - -import android.net.Uri; -import android.util.Log; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UpProgressBytesHandler; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.utils.Etag; -import com.qiniu.android.utils.LogUtil; - -import org.json.JSONObject; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; -import java.io.RandomAccessFile; - -public class UploadBaseTest extends BaseTest { - - @Override - protected void setUp() throws Exception { - super.setUp(); - LogUtil.enableLog(true); - LogUtil.setLogLevel(Log.VERBOSE); - } - - protected UploadOptions defaultOptions = new UploadOptions(null, null, true, new UpProgressBytesHandler() { - @Override - public void progress(String key, long uploadBytes, long totalBytes) { - double percent = 0; - if (totalBytes > 0) { - percent = (double) uploadBytes / (double) totalBytes; - } - LogUtil.d("== upload key:" + (key == null ? "" : key) + " uploadBytes:" + uploadBytes + " totalBytes:" + totalBytes + " percent:" + percent); - } - - @Override - public void progress(String key, double percent) { - LogUtil.d("== upload key:" + (key == null ? "" : key) + " progress:" + percent); - } - }, null); - - protected boolean verifyUploadKey(String upKey, String responseKey) { - LogUtil.d("== upKey:" + (upKey != null ? upKey : "") - + " responseKey:" + (responseKey != null ? responseKey : "")); - if (upKey == null) { - return responseKey == null; - } - if (responseKey == null) { - return false; - } - return upKey.equals(responseKey); - } - - protected void uploadFileAndAssertSuccessResult(File file, - String key, - Configuration configuration, - UploadOptions options) { - uploadFileAndAssertResult(ResponseInfo.RequestSuccess, file, key, configuration, options); - } - - protected void uploadFileAndAssertSuccessResult(UploadInfo file, - String key, - Configuration configuration, - UploadOptions options) { - uploadFileAndAssertResult(ResponseInfo.RequestSuccess, file, key, configuration, options); - } - - protected void uploadFileAndAssertResult(int statusCode, - File file, - String key, - Configuration configuration, - UploadOptions options) { - - uploadFileAndAssertResult(statusCode, file, TestConfig.token_na0, key, configuration, options); - } - - protected void uploadFileAndAssertResult(int statusCode, - UploadInfo file, - String key, - Configuration configuration, - UploadOptions options) { - - uploadFileAndAssertResult(statusCode, file, TestConfig.token_na0, key, configuration, options); - } - - protected void uploadFileAndAssertResult(int statusCode, - File file, - String token, - String key, - Configuration configuration, - UploadOptions options) { - - UploadInfo fileInfo = new UploadInfo<>(file); - fileInfo.configWithFile(file); - uploadFileAndAssertResult(statusCode, fileInfo, token, key, configuration, options); - - Uri uri = Uri.fromFile(file); - UploadInfo uriInfo = new UploadInfo<>(uri); - uriInfo.configWithFile(file); - uploadFileAndAssertResult(statusCode, uriInfo, token, key, configuration, options); - - InputStream stream = null; - try { - stream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - UploadInfo streamInfo = new UploadInfo<>(stream); - streamInfo.configWithFile(file); - uploadFileAndAssertResult(statusCode, streamInfo, token, key, configuration, options); - if (stream != null) { - try { - stream.close(); - } catch (IOException e) { - } - } - - try { - stream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - streamInfo = new UploadInfo<>(stream); - streamInfo.configWithFile(file); - streamInfo.size = -1; - uploadFileAndAssertResult(statusCode, streamInfo, token, key, configuration, options); - if (stream != null) { - try { - stream.close(); - } catch (IOException e) { - } - } - - if (file.length() < 4 * 1024 * 1024) { - byte[] data = getDataFromFile(file); - UploadInfo dataInfo = new UploadInfo<>(data); - dataInfo.configWithFile(file); - uploadFileAndAssertResult(statusCode, dataInfo, token, key, configuration, options); - } - } - - protected void uploadFileAndAssertResult(int statusCode, - UploadInfo file, - String token, - String key, - Configuration configuration, - UploadOptions options) { - - final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); - upload(file, token, key, configuration, options, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - completeInfo.responseInfo = info; - completeInfo.key = key; - } - }); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return completeInfo.responseInfo == null; - } - }, 10 * 60); - - LogUtil.d("=== upload file type:" + file.type() + " response key:" + (key != null ? key : "") + " response:" + completeInfo.responseInfo); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.statusCode == statusCode); - assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); - - // 成功验证 etag - if (statusCode == ResponseInfo.RequestSuccess) { - String etag = file.etag; - String serverEtag = null; - try { - serverEtag = completeInfo.responseInfo.response.getString("hash"); - } catch (Exception e) { - e.printStackTrace(); - } - LogUtil.d("=== upload etag:" + etag + " response etag:" + serverEtag); - assertEquals("file:" + etag + " server etag:" + serverEtag, etag, serverEtag); - } - } - - protected void upload(UploadInfo file, - String key, - Configuration configuration, - UploadOptions options, - UpCompletionHandler completionHandler) { - - upload(file, TestConfig.token_na0, key, configuration, options, completionHandler); - } - - protected void upload(UploadInfo file, - String token, - String key, - Configuration configuration, - UploadOptions options, - UpCompletionHandler completionHandler) { - if (options == null) { - options = defaultOptions; - } - UploadManager manager = new UploadManager(configuration); - if (file.info instanceof File) { - manager.put((File) file.info, key, token, completionHandler, options); - } else if (file.info instanceof Uri) { - manager.put((Uri) file.info, getContext().getContentResolver(), key, token, completionHandler, options); - } else if (file.info instanceof InputStream) { - manager.put((InputStream) file.info, null, file.size, file.fileName, key, token, completionHandler, options); - } else if (file.info instanceof byte[]) { - manager.put((byte[]) file.info, key, token, completionHandler, options); - } else { - completionHandler.complete(key, ResponseInfo.fileError(new Exception("test case file type error")), null); - } - } - - protected byte[] getDataFromFile(File file) { - byte[] bytes = new byte[(int) file.length()]; - try { - RandomAccessFile accessFile = new RandomAccessFile(file, "r"); - accessFile.readFully(bytes); - } catch (Exception e) { - bytes = null; - } - return bytes; - } - - protected static class UploadInfo { - protected final T info; - protected String fileName; - protected long size = -1; - protected String etag; - protected String md5; - - public UploadInfo(T info) { - this.info = info; - } - - public void configWithFile(File file) { - fileName = file.getName(); - size = file.length(); - try { - etag = Etag.file(file); - } catch (Exception ignore) { - } - - try { - etag = Etag.file(file); - } catch (Exception ignore) { - } - } - - public String type() { - if (info instanceof File) { - return "file"; - } else if (info instanceof Uri) { - return "uri"; - } else if (info instanceof InputStream) { - return "stream"; - } else if (info instanceof byte[]) { - return "byte_array"; - } else { - return "none"; - } - } - } - - protected static class UploadCompleteInfo { - String key; - ResponseInfo responseInfo; - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadDomainRegionTest.java b/library/src/androidTest/java/com/qiniu/android/UploadDomainRegionTest.java deleted file mode 100644 index 148ffa610..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadDomainRegionTest.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.http.request.IUploadServer; -import com.qiniu.android.http.request.UploadRequestState; -import com.qiniu.android.http.serverRegion.UploadDomainRegion; -import com.qiniu.android.http.serverRegion.UploadServerFreezeManager; -import com.qiniu.android.utils.Utils; - -public class UploadDomainRegionTest extends BaseTest { - - - public void testGetOneServer(){ - - String host = "baidu.com"; - String type = Utils.getIpType(null, host); - FixedZone zone = new FixedZone(new String[]{host}); - - UploadDomainRegion region = new UploadDomainRegion(); - region.setupRegionData(zone.getZonesInfo(null).zonesInfo.get(0)); - - UploadServerFreezeManager.getInstance().freezeType(type, 100); - - UploadRequestState state = new UploadRequestState(); - state.setUseOldServer(false); - IUploadServer server = region.getNextServer(state, null, null); - - assertNotNull(server); - } - -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadFlowTest.java b/library/src/androidTest/java/com/qiniu/android/UploadFlowTest.java deleted file mode 100644 index fbc20229c..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadFlowTest.java +++ /dev/null @@ -1,362 +0,0 @@ -package com.qiniu.android; - -import android.net.Uri; - -import com.qiniu.android.common.FixedZone; -import com.qiniu.android.common.ZoneInfo; -import com.qiniu.android.common.ZonesInfo; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.FileRecorder; -import com.qiniu.android.storage.UpCancellationSignal; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UpProgressBytesHandler; -import com.qiniu.android.storage.UploadOptions; -import com.qiniu.android.utils.LogUtil; -import com.qiniu.android.utils.Utils; - -import org.json.JSONObject; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; -import java.util.ArrayList; - -public class UploadFlowTest extends UploadBaseTest { - - protected void cancelTest(long cancelPosition, - File file, - String key, - Configuration configuration, - UploadOptions options) { - cancelPosition *= 1024; - - LogUtil.d("======== progress File cancel ============================================"); - UploadInfo fileInfo = new UploadInfo<>(file); - fileInfo.configWithFile(file); - cancelTest(cancelPosition, fileInfo, key, configuration, options); - - Uri uri = Uri.fromFile(file); - UploadInfo uriInfo = new UploadInfo<>(uri); - uriInfo.configWithFile(file); - cancelTest(cancelPosition, uriInfo, key, configuration, options); - - LogUtil.d("======== progress InputStream with size cancel ==========================="); - InputStream stream = null; - try { - stream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - UploadInfo streamInfo = new UploadInfo<>(stream); - streamInfo.configWithFile(file); - cancelTest(cancelPosition, streamInfo, key, configuration, options); - - LogUtil.d("======== progress InputStream without size cancel ========================="); - stream = null; - try { - stream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - streamInfo = new UploadInfo<>(stream); - streamInfo.configWithFile(file); - streamInfo.size = -1; - cancelTest(cancelPosition, streamInfo, key, configuration, options); - - LogUtil.d("======== progress data cancel ============================================="); - if (file.length() < 4 * 1024 * 1024) { - byte[] data = getDataFromFile(file); - UploadInfo dataInfo = new UploadInfo<>(data); - dataInfo.configWithFile(file); - cancelTest(cancelPosition, dataInfo, key, configuration, options); - } - } - - private void cancelTest(final long cancelPosition, - UploadInfo file, - String key, - Configuration configuration, - UploadOptions options) { - - if (options == null) { - options = defaultOptions; - } - - final UploadOptions optionsReal = options; - final Flags flags = new Flags(); - UploadOptions cancelOptions = new UploadOptions(optionsReal.params, optionsReal.mimeType, optionsReal.checkCrc, new UpProgressBytesHandler() { - @Override - public void progress(String key, long uploadBytes, long totalBytes) { - if (cancelPosition < uploadBytes) { - flags.shouldCancel = true; - } - if (optionsReal.progressHandler instanceof UpProgressBytesHandler) { - ((UpProgressBytesHandler)optionsReal.progressHandler).progress(key, uploadBytes, totalBytes); - } - } - - @Override - public void progress(String key, double percent) { - } - }, new UpCancellationSignal() { - @Override - public boolean isCancelled() { - - return flags.shouldCancel; - } - }, options.netReadyHandler); - - final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); - upload(file, key, configuration, cancelOptions, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - completeInfo.key = key; - completeInfo.responseInfo = info; - } - }); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return completeInfo.responseInfo == null; - } - }, 5 * 60); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.isCancelled()); - assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); - } - - protected void reuploadUploadTest(long resumePosition, - File file, - String key, - Configuration configuration, - UploadOptions options) { - - resumePosition *= 1024; - - LogUtil.d("======== progress File ReUpload =============================================="); - UploadInfo fileInfo = new UploadInfo<>(file); - fileInfo.configWithFile(file); - reuploadUploadTest(resumePosition, fileInfo, fileInfo, key, configuration, options); - - LogUtil.d("======== progress Uri ReUpload =============================================="); - Uri uri = Uri.fromFile(file); - UploadInfo uriInfo = new UploadInfo<>(uri); - uriInfo.configWithFile(file); - reuploadUploadTest(resumePosition, uriInfo, uriInfo, key, configuration, options); - - LogUtil.d("======== progress InputStream with size ReUpload ============================="); - InputStream firstStream = null; - try { - firstStream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - UploadInfo firstStreamInfo = new UploadInfo<>(firstStream); - firstStreamInfo.configWithFile(file); - - InputStream secondStream = null; - try { - secondStream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - UploadInfo secondStreamInfo = new UploadInfo<>(secondStream); - secondStreamInfo.configWithFile(file); - - reuploadUploadTest(resumePosition, firstStreamInfo, secondStreamInfo, key, configuration, options); - try { - firstStream.close(); - secondStream.close(); - } catch (IOException e) { - } - - LogUtil.d("======== progress InputStream without size ReUpload =========================="); - firstStream = null; - try { - firstStream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - firstStreamInfo = new UploadInfo<>(firstStream); - firstStreamInfo.configWithFile(file); - firstStreamInfo.size = -1; - - secondStream = null; - try { - secondStream = new FileInputStream(file); - } catch (FileNotFoundException e) { - } - secondStreamInfo = new UploadInfo<>(secondStream); - secondStreamInfo.configWithFile(file); - secondStreamInfo.size = -1; - - reuploadUploadTest(resumePosition, firstStreamInfo, secondStreamInfo, key, configuration, options); - try { - firstStream.close(); - secondStream.close(); - } catch (IOException e) { - } - } - - private void reuploadUploadTest(final long resumePosition, - final UploadInfo firstFile, - final UploadInfo secondFile, - String key, - final Configuration configuration, - UploadOptions options) { - - FileRecorder fileRecorder = null; - try { - fileRecorder = new FileRecorder(Utils.sdkDirectory() + "/Test"); - } catch (IOException e) { - e.printStackTrace(); - } - - final Configuration reuploadConfiguration = new Configuration.Builder() - .chunkSize(configuration.chunkSize) - .putThreshold(configuration.putThreshold) - .retryMax(configuration.retryMax) - .connectTimeout(configuration.connectTimeout) - .responseTimeout(configuration.responseTimeout) - .retryInterval(configuration.retryInterval) - .recorder(fileRecorder, null) - .proxy(configuration.proxy) - .urlConverter(configuration.urlConverter) - .useHttps(configuration.useHttps) - .allowBackupHost(configuration.allowBackupHost) - .useConcurrentResumeUpload(configuration.useConcurrentResumeUpload) - .resumeUploadVersion(configuration.resumeUploadVersion) - .concurrentTaskCount(configuration.concurrentTaskCount) - .zone(configuration.zone) - .build(); - - - if (options == null) { - options = defaultOptions; - } - final UploadOptions optionsReal = options; - - cancelTest(resumePosition, firstFile, key, reuploadConfiguration, optionsReal); - - LogUtil.d("progress ReUpload ===================================================="); - - final Flags flags = new Flags(); - UploadOptions reuploadOptions = new UploadOptions(optionsReal.params, optionsReal.mimeType, optionsReal.checkCrc, new UpProgressBytesHandler() { - @Override - public void progress(String key, double percent) { - } - - @Override - public void progress(String key, long uploadBytes, long totalBytes) { - if (!flags.flags) { - flags.flags = true; - if (uploadBytes <= resumePosition && uploadBytes > 0) { - flags.isSuccess = true; - } - } - - if (optionsReal.progressHandler != null && optionsReal.progressHandler instanceof UpProgressBytesHandler) { - ((UpProgressBytesHandler)optionsReal.progressHandler).progress(key, uploadBytes, totalBytes); - } - } - }, null, options.netReadyHandler); - - final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); - upload(secondFile, key, reuploadConfiguration, reuploadOptions, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - completeInfo.key = key; - completeInfo.responseInfo = info; - } - }); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return completeInfo.responseInfo == null; - } - }, 10* 60); - assertTrue(completeInfo.responseInfo.toString(), flags.isSuccess); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.isOK()); - assertTrue(completeInfo.responseInfo.toString(), verifyUploadKey(key, completeInfo.key)); - } - - protected void switchRegionTestWithFile(File file, - String key, - Configuration configuration, - UploadOptions options) { - - UploadInfo fileInfo = new UploadInfo<>(file); - fileInfo.configWithFile(file); - switchRegionTestWithFile(fileInfo, key, configuration, options); - - Uri uri = Uri.fromFile(file); - UploadInfo uriInfo = new UploadInfo<>(uri); - uriInfo.configWithFile(file); - switchRegionTestWithFile(uriInfo, key, configuration, options); - - if (file.length() < 4 * 1024 * 1024) { - byte[] data = getDataFromFile(file); - UploadInfo dataInfo = new UploadInfo<>(data); - dataInfo.configWithFile(file); - switchRegionTestWithFile(dataInfo, key, configuration, options); - } - } - - private void switchRegionTestWithFile(UploadInfo file, - String key, - Configuration configuration, - UploadOptions options) { - if (configuration == null) { - configuration = new Configuration.Builder().build(); - } - Configuration configurationReal = configuration; - - ArrayList hostArray0 = new ArrayList<>(); - hostArray0.add("mock1.up.qiniup.com"); - hostArray0.add("mock2.up.qiniup.com"); - ZoneInfo zoneInfo0 = ZoneInfo.buildInfo(hostArray0, null, null); - - ArrayList hostArray1 = new ArrayList<>(); - hostArray1.add("upload.qiniup.com"); - hostArray1.add("up.qiniup.com"); - ZoneInfo zoneInfo1 = ZoneInfo.buildInfo(hostArray1, null, null); - - ArrayList hostArray2 = new ArrayList<>(); - hostArray2.add("upload-na0.qiniup.com"); - hostArray2.add("up-na0.qiniup.com"); - ZoneInfo zoneInfo2 = ZoneInfo.buildInfo(hostArray2, null, null); - - ArrayList zoneInfoArray = new ArrayList<>(); - zoneInfoArray.add(zoneInfo0); - zoneInfoArray.add(zoneInfo1); - zoneInfoArray.add(zoneInfo2); - ZonesInfo zonesInfo = new ZonesInfo(zoneInfoArray); - FixedZone zone = new FixedZone(zonesInfo); - - Configuration switchConfiguration = new Configuration.Builder() - .chunkSize(configurationReal.chunkSize) - .putThreshold(configurationReal.putThreshold) - .retryMax(configurationReal.retryMax) - .connectTimeout(configurationReal.connectTimeout) - .responseTimeout(configurationReal.responseTimeout) - .retryInterval(configurationReal.retryInterval) - .recorder(configurationReal.recorder, configurationReal.keyGen) - .proxy(configurationReal.proxy) - .urlConverter(configurationReal.urlConverter) - .useHttps(configurationReal.useHttps) - .allowBackupHost(configurationReal.allowBackupHost) - .useConcurrentResumeUpload(configurationReal.useConcurrentResumeUpload) - .resumeUploadVersion(configurationReal.resumeUploadVersion) - .concurrentTaskCount(configurationReal.concurrentTaskCount) - .zone(zone) - .build(); - uploadFileAndAssertSuccessResult(file, key, switchConfiguration, options); - } - - protected static class Flags { - boolean flags; - boolean shouldCancel; - boolean isSuccess; - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadInfoReporterTest.java b/library/src/androidTest/java/com/qiniu/android/UploadInfoReporterTest.java deleted file mode 100644 index b9ca94a39..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadInfoReporterTest.java +++ /dev/null @@ -1,115 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.collect.ReportConfig; -import com.qiniu.android.collect.ReportItem; -import com.qiniu.android.collect.UploadInfoReporter; -import com.qiniu.android.utils.LogUtil; - -import java.io.BufferedReader; -import java.io.File; -import java.io.FileReader; -import java.io.IOException; -import java.util.Date; -import java.util.concurrent.CountDownLatch; - -/** - * Created by yangsen on 2020/5/25 - */ -public class UploadInfoReporterTest extends BaseTest { - - private CountDownLatch signal = null; - - private class TestParam{ - int totalCount = 50; - int completeCount = 0; - } - - public void testNoReporter(){ - ReportConfig.getInstance().isReportEnable = false; - - report(null); - ReportItem item = new ReportItem(); - item.setReport(ReportItem.LogTypeQuality, ReportItem.QualityKeyLogType); - item.setReport((new Date().getTime() / 1000), ReportItem.QualityKeyUpTime); - item.setReport("ok", ReportItem.QualityKeyResult); - item.setReport(1, ReportItem.QualityKeyTotalElapsedTime); - item.setReport(1, ReportItem.QualityKeyRequestsCount); - item.setReport(1, ReportItem.QualityKeyRegionsCount); - item.setReport(1, ReportItem.QualityKeyBytesSent); - report(item); - - wait(null, 1); - - ReportConfig.getInstance().isReportEnable = true; - } - - public void testSave(){ - - UploadInfoReporter.getInstance().clean(); - signal = new CountDownLatch(1); - final String time = new Date().toString(); - for (int i = 0; i < 50; i++) { - final int iP = i; - new Thread(new Runnable() { - @Override - public void run() { - ReportItem item = new ReportItem(); - item.setReport(ReportItem.LogTypeQuality, ReportItem.QualityKeyLogType); - item.setReport((new Date().getTime() / 1000), ReportItem.QualityKeyUpTime); - item.setReport("ok", ReportItem.QualityKeyResult); - item.setReport(1, ReportItem.QualityKeyTotalElapsedTime); - item.setReport(1, ReportItem.QualityKeyRequestsCount); - item.setReport(1, ReportItem.QualityKeyRegionsCount); - item.setReport(1, ReportItem.QualityKeyBytesSent); - report(item); - } - }).start(); - } - - wait(null, 5); - - File logFile = new File(ReportConfig.getInstance().recordDirectory + "/qiniu.log"); - showContent(logFile); - - File logTempFile = new File(ReportConfig.getInstance().recordDirectory + "/qiniuTemp.log"); - showContent(logTempFile); - - } - - private void report(ReportItem item){ - UploadInfoReporter reporter = UploadInfoReporter.getInstance(); - reporter.report(item, TestConfig.token_z0); - } - - private static void showContent(File recordFile) { - FileReader fileReader = null; - BufferedReader br = null; - try { - fileReader = new FileReader(recordFile); - br = new BufferedReader(fileReader); - String line = null; - LogUtil.d("== " + recordFile.getPath() + ": start"); - while ((line = br.readLine()) != null) { - LogUtil.d(("== " + line)); - } - LogUtil.d("== " + recordFile.getPath() + ": end"); - } catch (Exception e) { - - } finally { - if (br != null) { - try { - br.close(); - } catch (IOException e) { - e.printStackTrace(); - } - } - if (fileReader != null) { - try { - fileReader.close(); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadReportItemTest.java b/library/src/androidTest/java/com/qiniu/android/UploadReportItemTest.java deleted file mode 100644 index 9a1f73118..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadReportItemTest.java +++ /dev/null @@ -1,100 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.collect.ReportItem; -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.http.request.Request; - -import org.json.JSONObject; - -import java.util.HashMap; - -public class UploadReportItemTest extends BaseTest { - - public void testSetAndRemoveValue(){ - - ReportItem reportItem = new ReportItem(); - reportItem.setReport(ReportItem.LogTypeRequest, ReportItem.RequestKeyLogType); - - String json = reportItem.toJson(); - assertTrue(! json.equals("{}")); - - reportItem.removeReportValue(ReportItem.RequestKeyLogType); - - json = reportItem.toJson(); - assertTrue(json.equals("{}")); - } - - public void testReportStatusCode(){ - ResponseInfo responseInfo = createResponseInfo(ResponseInfo.Cancelled); - assertTrue(ReportItem.requestReportStatusCode(responseInfo) != null); - - responseInfo = createResponseInfo(200); - assertTrue(ReportItem.requestReportStatusCode(responseInfo).equals("200")); - } - - public void testReportErrorType(){ - ResponseInfo responseInfo = createResponseInfo(200); - assertTrue(ReportItem.qualityResult(responseInfo).equals("ok")); - - responseInfo = createResponseInfo(400); - assertTrue(ReportItem.qualityResult(responseInfo).equals("bad_request")); - - responseInfo = createResponseInfo(ResponseInfo.ZeroSizeFile); - assertTrue(ReportItem.qualityResult(responseInfo).equals("zero_size_file")); - - responseInfo = createResponseInfo(ResponseInfo.InvalidFile); - assertTrue(ReportItem.qualityResult(responseInfo).equals("invalid_file")); - - responseInfo = createResponseInfo(ResponseInfo.InvalidToken); - assertTrue(ReportItem.qualityResult(responseInfo).equals("invalid_args")); - - responseInfo = createResponseInfo(ResponseInfo.NetworkError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("network_error")); - - responseInfo = createResponseInfo(ResponseInfo.TimedOut); - assertTrue(ReportItem.qualityResult(responseInfo).equals("timeout")); - - responseInfo = createResponseInfo(ResponseInfo.CannotConnectToHost); - assertTrue(ReportItem.qualityResult(responseInfo).equals("cannot_connect_to_host")); - - responseInfo = createResponseInfo(ResponseInfo.NetworkConnectionLost); - assertTrue(ReportItem.qualityResult(responseInfo).equals("transmission_error")); - - responseInfo = createResponseInfo(ResponseInfo.NetworkSSLError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("ssl_error")); - - responseInfo = createResponseInfo(ResponseInfo.ParseError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("parse_error")); - - responseInfo = createResponseInfo(ResponseInfo.MaliciousResponseError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("malicious_response")); - - responseInfo = createResponseInfo(ResponseInfo.Cancelled); - assertTrue(ReportItem.qualityResult(responseInfo).equals("user_canceled")); - - responseInfo = createResponseInfo(ResponseInfo.LocalIOError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("local_io_error")); - - responseInfo = createResponseInfo(ResponseInfo.NetworkProtocolError); - assertTrue(ReportItem.qualityResult(responseInfo).equals("protocol_error")); - - responseInfo = createResponseInfo(ResponseInfo.NetworkSlow); - assertTrue(ReportItem.qualityResult(responseInfo).equals("network_slow")); - - responseInfo = createResponseInfo(614); - assertTrue(ReportItem.qualityResult(responseInfo).equals("bad_request")); - } - - - private ResponseInfo createResponseInfo(int statusCode){ - - HashMaprequestHeader = new HashMap<>(); - - Request request = new Request("url", "GET", requestHeader, null, 10); - - HashMapresponseHeader = new HashMap<>(); - responseHeader.put("x-reqid", "req-id"); - responseHeader.put("x-log", "log"); - return ResponseInfo.create(request, statusCode, responseHeader, new JSONObject(), ""); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UploadServerFreezeManagerTest.java b/library/src/androidTest/java/com/qiniu/android/UploadServerFreezeManagerTest.java deleted file mode 100644 index 007907f91..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UploadServerFreezeManagerTest.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.http.serverRegion.UploadServerFreezeManager; - -public class UploadServerFreezeManagerTest extends BaseTest { - - public void testFreeze() { - - String host = "baidu.com"; - String type = host; - UploadServerFreezeManager.getInstance().freezeType(type, 10); - - boolean isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); - assertTrue(isFrozen); - } - - public void testUnfreeze() { - - String host = "baidu.com"; - String type = host; - UploadServerFreezeManager.getInstance().freezeType(type, 10); - - boolean isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); - assertTrue(isFrozen); - - UploadServerFreezeManager.getInstance().unfreezeType(type); - isFrozen = UploadServerFreezeManager.getInstance().isTypeFrozen(type); - assertTrue(isFrozen == false); - - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UplogTest.java b/library/src/androidTest/java/com/qiniu/android/UplogTest.java deleted file mode 100644 index 8f22d94a9..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UplogTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.collect.ReportItem; -import com.qiniu.android.collect.UploadInfoReporter; - -public class UplogTest extends BaseTest { - - public void no_testUplog() { - ReportItem item = new ReportItem(); - item.setReport(ReportItem.LogTypeRequest, ReportItem.RequestKeyLogType); - item.setReport(1634567890, ReportItem.RequestKeyUpTime); - item.setReport(200, ReportItem.RequestKeyStatusCode); - item.setReport("reqid", ReportItem.RequestKeyRequestId); - item.setReport("host", ReportItem.RequestKeyHost); - item.setReport("remoteAddress", ReportItem.RequestKeyRemoteIp); - item.setReport(80, ReportItem.RequestKeyPort); - item.setReport("bucket", ReportItem.RequestKeyTargetBucket); - item.setReport("key", ReportItem.RequestKeyTargetKey); - item.setReport(123, ReportItem.RequestKeyTotalElapsedTime); - item.setReport(123, ReportItem.RequestKeyDnsElapsedTime); - item.setReport(123, ReportItem.RequestKeyConnectElapsedTime); - item.setReport(123, ReportItem.RequestKeyTLSConnectElapsedTime); - item.setReport(123, ReportItem.RequestKeyRequestElapsedTime); - item.setReport(123, ReportItem.RequestKeyWaitElapsedTime); - item.setReport(123, ReportItem.RequestKeyResponseElapsedTime); - item.setReport(123, ReportItem.RequestKeyFileOffset); - item.setReport(123, ReportItem.RequestKeyBytesSent); - item.setReport(123, ReportItem.RequestKeyBytesTotal); - item.setReport("123", ReportItem.RequestKeyPid); - item.setReport(123, ReportItem.RequestKeyTid); - item.setReport("regionid", ReportItem.RequestKeyTargetRegionId); - item.setReport("regionid", ReportItem.RequestKeyCurrentRegionId); - item.setReport("errorType", ReportItem.RequestKeyErrorType); - - item.setReport("errorDesc", ReportItem.RequestKeyErrorDescription); - item.setReport("form", ReportItem.RequestKeyUpType); - item.setReport("android", ReportItem.RequestKeyOsName); - item.setReport("10", ReportItem.RequestKeyOsVersion); - item.setReport("Android", ReportItem.RequestKeySDKName); - item.setReport("8.3.3", ReportItem.RequestKeySDKVersion); - item.setReport(1623456789, ReportItem.RequestKeyClientTime); - item.setReport("wifi", ReportItem.RequestKeyNetworkType); - item.setReport(-1, ReportItem.RequestKeySignalStrength); - - item.setReport("server", ReportItem.RequestKeyPrefetchedDnsSource); - item.setReport(10, ReportItem.RequestKeyPrefetchedBefore); - item.setReport("lastPrefetchErrorMessage", ReportItem.RequestKeyPrefetchedErrorMessage); - - item.setReport("okhttp", ReportItem.RequestKeyHttpClient); - item.setReport("4.2.2", ReportItem.RequestKeyHttpClientVersion); - item.setReport("disable", ReportItem.RequestKeyNetworkMeasuring); - - // 劫持标记 - item.setReport("hijacked", ReportItem.RequestKeyHijacking); - item.setReport("syncDnsSource", ReportItem.RequestKeyDnsSource); - item.setReport("syncDnsError", ReportItem.RequestKeyDnsErrorMessage); - - // 统计当前请求上传速度 / 总耗时 - item.setReport(123, ReportItem.RequestKeyPerceptiveSpeed); - - item.setReport("http1.1", ReportItem.RequestKeyHttpVersion); - - UploadInfoReporter.getInstance().report(item, TestConfig.commonToken); - -// wait(new WaitConditional() { -// @Override -// public boolean shouldWait() { -// return true; -// } -// }, 10 * 60); - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UriTest.java b/library/src/androidTest/java/com/qiniu/android/UriTest.java deleted file mode 100644 index 57487d345..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UriTest.java +++ /dev/null @@ -1,197 +0,0 @@ -package com.qiniu.android; - -import android.content.ContentResolver; -import android.content.ContentValues; -import android.net.Uri; -import android.provider.MediaStore; - -import com.qiniu.android.http.ResponseInfo; -import com.qiniu.android.storage.Configuration; -import com.qiniu.android.storage.UpCompletionHandler; -import com.qiniu.android.storage.UploadManager; -import com.qiniu.android.utils.ContextGetter; -import com.qiniu.android.utils.Etag; -import com.qiniu.android.utils.LogUtil; - -import junit.framework.Assert; - -import org.json.JSONException; -import org.json.JSONObject; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; - -public class UriTest extends BaseTest { - - private static boolean[][] testConfigList = { - {true, true, true}, - {true, true, false}, - {true, false, true}, - {true, false, false}, - - {false, true, true}, - {false, true, false}, - {false, false, true}, - {false, false, false}, - }; - - public void notestUpload() { - int MB = 1024; - int[] sizeList = {512, MB, 4*MB, 5*MB, 8*MB, 10*MB, 20*MB}; - for (int size : sizeList) { - String fileName = size + "KB" + ".mp4"; - - File file = createFile(size); - Uri uri = null; - try { - uri = writeFileToDownload(file, fileName); - } catch (FileNotFoundException e) { - e.printStackTrace(); - Assert.fail(e.getMessage()); - return; - } - - String etag = null; - try { - etag = Etag.file(file); - } catch (IOException e) { - e.printStackTrace(); - } - for (boolean[] config : testConfigList) { - testUpload(uri, fileName, etag, config[0], config[1], config[2]); - } - removeUri(uri); - } - } - - - public void no_testUpload() { - String uriString = "content://media/external/images/media/12045"; - Uri uri = Uri.parse(uriString); - testUpload(uri, "uri_test", "AAAA", true, false, false); - } - - private void testUpload(Uri uri, String fileName, String etag, boolean isHttps, boolean isResumableV1, boolean isConcurrent) { - - assertNotNull("Uri write file error:" + fileName, uri); - - Configuration configuration = new Configuration.Builder() - .resumeUploadVersion(isResumableV1 ? Configuration.RESUME_UPLOAD_VERSION_V1 : Configuration.RESUME_UPLOAD_VERSION_V2) - .chunkSize(isResumableV1 ? 1024*1024*2 : 1024*1024*4) - .useConcurrentResumeUpload(isConcurrent) - .useHttps(isHttps) - .build(); - - UploadManager uploadManager = new UploadManager(configuration); - - String key = "uri_upload_"; - key += isHttps ? "https_" : "http_"; - key += isResumableV1 ? "v1_" : "v2_"; - key += isConcurrent ? "serial_" : "concurrent_"; - key += fileName; - final UploadCompleteInfo completeInfo = new UploadCompleteInfo(); - uploadManager.put(uri, null, key, TestConfig.token_na0, new UpCompletionHandler() { - @Override - public void complete(String key, ResponseInfo info, JSONObject response) { - completeInfo.key = key; - completeInfo.responseInfo = info; - } - }, null); - - wait(new WaitConditional() { - @Override - public boolean shouldWait() { - return completeInfo.responseInfo == null; - } - }, 10 * 60); - - LogUtil.d("=== upload response key:" + (key != null ? key : "") + " response:" + completeInfo.responseInfo); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo != null); - assertTrue(completeInfo.responseInfo.toString(), completeInfo.responseInfo.statusCode == ResponseInfo.RequestSuccess); - assertTrue(completeInfo.responseInfo.toString(), key.equals(completeInfo.key)); - - String serverEtag = null; - try { - serverEtag = completeInfo.responseInfo.response.getString("hash"); - } catch (JSONException e) { - e.printStackTrace(); - } - System.out.println(" etag:" + etag); - System.out.println("serverEtag:" + serverEtag); - assertNotNull("key:" + key, serverEtag); - assertEquals("key:" + key, etag, serverEtag); - } - - private File createFile(int size) { - File file = null; - try { - file = TempFile.createFile(size); - } catch (IOException e) { - e.printStackTrace(); - } - return file; - } - - private Uri writeFileToDownload(File file, String fileName) throws FileNotFoundException { - - InputStream inputStream = null; - try { - inputStream = new FileInputStream(file); - } catch (FileNotFoundException e) { - e.printStackTrace(); - throw e; - } - - ContentResolver resolver = ContextGetter.applicationContext().getContentResolver(); - - ContentValues contentValues = new ContentValues(); - contentValues.put(MediaStore.Video.Media.DISPLAY_NAME, fileName); - Uri imageUri = null; - try { - imageUri = resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues); - } catch (Exception e) { - e.printStackTrace(); - throw e; - } - - if (imageUri != null) { - // 若生成了uri，则表示该文件添加成功 - // 使用流将内容写入该uri中即可 - OutputStream outputStream = null; - try { - outputStream = resolver.openOutputStream(imageUri); - } catch (FileNotFoundException e) { - e.printStackTrace(); - } - if (outputStream != null) { - try { - byte[] buf = new byte[1024]; - int len; - while ((len = inputStream.read(buf)) > 0) { - outputStream.write(buf, 0, len); - } - outputStream.close(); - inputStream.close(); - } catch (Exception e) { - e.printStackTrace(); - } - } - } - - return imageUri; - } - - private void removeUri(Uri uri) { - ContentResolver resolver = ContextGetter.applicationContext().getContentResolver(); - resolver.delete(uri, null, null); - } - - protected static class UploadCompleteInfo { - String key; - ResponseInfo responseInfo; - } -} diff --git a/library/src/androidTest/java/com/qiniu/android/UtilsTest.java b/library/src/androidTest/java/com/qiniu/android/UtilsTest.java deleted file mode 100644 index 3c950feef..000000000 --- a/library/src/androidTest/java/com/qiniu/android/UtilsTest.java +++ /dev/null @@ -1,69 +0,0 @@ -package com.qiniu.android; - -import com.qiniu.android.utils.Utils; - -public class UtilsTest extends BaseTest { - - public void testIPType(){ - - String testHost = "host"; - String type = ""; - - type = Utils.getIpType("10.10.120.3", testHost); - assertTrue(type.equals(testHost + "-10-10")); - - type = Utils.getIpType("130.101.120.3", testHost); - assertTrue(type.equals(testHost + "-130-101")); - - type = Utils.getIpType("2000:0000:0000:0000:0001:2345:6789:abcd", testHost); - assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); - - type = Utils.getIpType("2000:0:0:0:0001:2345:6789:abcd", testHost); - assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); - - type = Utils.getIpType("2000::0001:2345:6789:abcd", testHost); - assertTrue(type.equals(testHost + "-ipv6-2000-0000-0000-0000")); - } - - public void testIsIPType(){ - - String ip = null; - boolean isIpv6 = false; - - ip = "10.10.120.3"; - isIpv6 = Utils.isIpv6(ip); - assertFalse(ip, isIpv6); - - ip = "130.101.120.3"; - isIpv6 = Utils.isIpv6(ip); - assertFalse(ip, isIpv6); - - ip = "2000:0000:0000:0000:0001:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "2000:0:0:0:0001:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "2000::0001:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "0::0"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "ffff::ffff:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "ff1::ffff:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertTrue(ip, isIpv6); - - ip = "ffff1::ffff:2345:6789:abcd"; - isIpv6 = Utils.isIpv6(ip); - assertFalse(ip, isIpv6); - } -} From 857d4debfec21b1b145e46dfa9804ebc528364a9 Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 28 Jul 2022 14:11:36 +0800 Subject: [PATCH 03/12] update test case lib --- build.gradle | 2 +- gradle.properties | 2 ++ gradle/wrapper/gradle-wrapper.properties | 6 +++--- library/build.gradle | 2 ++ .../src/androidTest/java/com/qiniu/android/BaseTest.java | 8 +------- .../java/com/qiniu/android/collect/UplogTest.java | 5 +++++ .../java/com/qiniu/android/http/HttpHeaderTest.java | 2 +- .../java/com/qiniu/android/http/dns/DnsApiTest.java | 3 +-- .../com/qiniu/android/http/dns/DnsTransactionTest.java | 6 ++++-- .../java/com/qiniu/android/storage/UploadBaseTest.java | 4 ++-- .../java/com/qiniu/android/storage/UploadFlowTest.java | 4 +++- .../java/com/qiniu/android/storage/UriTest.java | 7 +++++-- settings.gradle | 1 + 13 files changed, 31 insertions(+), 21 deletions(-) diff --git a/build.gradle b/build.gradle index e8108abd2..512ef2331 100644 --- a/build.gradle +++ b/build.gradle @@ -9,7 +9,7 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.5.4' + classpath 'com.android.tools.build:gradle:3.6.4' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } diff --git a/gradle.properties b/gradle.properties index 0ebdd1658..c9ad5421a 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,3 +1,5 @@ +android.useAndroidX=true + VERSION_NAME= VERSION_CODE= GROUP=com.qiniu diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index d91a4d647..078b8e4e3 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Mon Jun 28 14:50:04 CST 2021 +#Thu Jul 28 11:54:47 CST 2022 distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip distributionPath=wrapper/dists -zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip +zipStoreBase=GRADLE_USER_HOME diff --git a/library/build.gradle b/library/build.gradle index 9f1bd53b1..9d208217b 100755 --- a/library/build.gradle +++ b/library/build.gradle @@ -28,6 +28,8 @@ android { targetSdkVersion 30 versionCode code versionName version + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" } buildTypes { diff --git a/library/src/androidTest/java/com/qiniu/android/BaseTest.java b/library/src/androidTest/java/com/qiniu/android/BaseTest.java index 8ca1a1a41..3625c3e7f 100644 --- a/library/src/androidTest/java/com/qiniu/android/BaseTest.java +++ b/library/src/androidTest/java/com/qiniu/android/BaseTest.java @@ -4,11 +4,6 @@ import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; -import androidx.test.platform.app.InstrumentationRegistry; - -import com.qiniu.android.transaction.TransactionManager; - -import junit.framework.TestCase; import org.junit.Assert; import org.junit.Before; @@ -21,12 +16,11 @@ /** * Created by yangsen on 2020/5/26 */ -//@RunWith(AndroidJUnit4.class) public class BaseTest { private long maxWaitTimestamp = 0; - private Context context; + private Context context = ApplicationProvider.getApplicationContext(); @Before public void setUp() throws Exception { diff --git a/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java b/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java index b167826cc..e6be0aff7 100644 --- a/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java +++ b/library/src/androidTest/java/com/qiniu/android/collect/UplogTest.java @@ -5,11 +5,16 @@ import com.qiniu.android.TestConfig; import com.qiniu.android.BaseTest; +import org.junit.Test; import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) public class UplogTest extends BaseTest { + @Test + public void test() { + } + private void no_testUplog() { ReportItem item = new ReportItem(); item.setReport(ReportItem.LogTypeRequest, ReportItem.RequestKeyLogType); diff --git a/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java b/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java index d873857e9..ed88c2323 100644 --- a/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java +++ b/library/src/androidTest/java/com/qiniu/android/http/HttpHeaderTest.java @@ -19,7 +19,7 @@ public class HttpHeaderTest { private Headers headers; @Before - protected void setUp() throws Exception { + public void setUp() throws Exception { HashMap keyVaules = new HashMap<>(); keyVaules.put("date", "2020-07-15 07:40:01"); diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java index 34ce00c70..6805b664a 100644 --- a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsApiTest.java @@ -48,8 +48,7 @@ public boolean shouldWait() { assertTrue(addressList.size() > 0); } - @Test - public void testRecover(){ + private void testRecover(){ final String host = "uplog.qbox.me"; final DnsPrefetcher dnsPrefetcher = DnsPrefetcher.getInstance(); diff --git a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java index e1877eb06..0fb00af42 100644 --- a/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java +++ b/library/src/androidTest/java/com/qiniu/android/http/dns/DnsTransactionTest.java @@ -8,6 +8,7 @@ import com.qiniu.android.BaseTest; import com.qiniu.android.storage.UpToken; +import org.junit.Test; import org.junit.runner.RunWith; @@ -21,6 +22,7 @@ public class DnsTransactionTest extends BaseTest { private int completeCount = 0; private int successCount = 0; + @Test public void testLocalLoad(){ completeCount = 0; @@ -54,7 +56,7 @@ public boolean shouldWait() { assertTrue(successCount < 2); } - + @Test public void test_CheckAndPrefetch(){ completeCount = 0; @@ -91,7 +93,7 @@ public boolean shouldWait() { assertTrue("successCount:" + successCount, successCount < 3); } - + @Test public void testCheckWhetherCachedValid(){ completeCount = 0; diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java index b699a0301..c54e62c6a 100644 --- a/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java +++ b/library/src/androidTest/java/com/qiniu/android/storage/UploadBaseTest.java @@ -22,10 +22,10 @@ import java.io.InputStream; import java.io.RandomAccessFile; -//@RunWith(AndroidJUnit4.class) public class UploadBaseTest extends BaseTest { - @Override @Before + @Override + @Before public void setUp() throws Exception { LogUtil.enableLog(true); LogUtil.setLogLevel(Log.VERBOSE); diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java index 2c6102a81..d690b0be4 100644 --- a/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java +++ b/library/src/androidTest/java/com/qiniu/android/storage/UploadFlowTest.java @@ -22,9 +22,11 @@ import java.io.InputStream; import java.util.ArrayList; -//@RunWith(AndroidJUnit4.class) public class UploadFlowTest extends UploadBaseTest { + public void test() { + } + protected void cancelTest(long cancelPosition, File file, String key, diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java index 50d707669..48f9c2b4b 100644 --- a/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java +++ b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java @@ -44,6 +44,9 @@ public class UriTest extends BaseTest { {false, false, false}, }; + public void test() { + } + private void notestUpload() { int MB = 1024; int[] sizeList = {512, MB, 4*MB, 5*MB, 8*MB, 10*MB, 20*MB}; @@ -74,8 +77,8 @@ private void notestUpload() { } - @Test - public void testUpload() { + + private void testUpload() { String uriString = "content://media/external/images/media/12045"; Uri uri = Uri.parse(uriString); testUpload(uri, "uri_test", "AAAA", true, false, false); diff --git a/settings.gradle b/settings.gradle index d8f14a134..da1798c7e 100755 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1,2 @@ +rootProject.name = "android-sdk" include ':library' From 4a7256485dab1ed62d06d165951088f4bfac76e3 Mon Sep 17 00:00:00 2001 From: yangsen Date: Tue, 20 Sep 2022 15:01:55 +0800 Subject: [PATCH 04/12] resume v1:check ctx expired & resume: region retry when 701 --- .../com/qiniu/android/http/ResponseInfo.java | 5 +++++ .../com/qiniu/android/storage/BaseUpload.java | 22 +++++++++++++++---- .../qiniu/android/storage/PartsUpload.java | 4 ++-- .../qiniu/android/storage/UploadBlock.java | 18 +++++++++++++++ .../qiniu/android/storage/UploadInfoV1.java | 21 ++++++++++++++++++ .../qiniu/android/storage/UploadInfoV2.java | 4 ++-- 6 files changed, 66 insertions(+), 8 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java index 8a048e799..d7df7a9b1 100644 --- a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java +++ b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java @@ -391,6 +391,11 @@ public boolean isHostUnavailable() { } } + // 在断点续上传过程中，ctx 信息已过期。 + public boolean isCtxExpiredError() { + return statusCode == 701; + } + public boolean isNetworkBroken() { return statusCode == NetworkError || statusCode == NetworkSlow; } diff --git a/library/src/main/java/com/qiniu/android/storage/BaseUpload.java b/library/src/main/java/com/qiniu/android/storage/BaseUpload.java index 772c21b9b..d109a06a7 100644 --- a/library/src/main/java/com/qiniu/android/storage/BaseUpload.java +++ b/library/src/main/java/com/qiniu/android/storage/BaseUpload.java @@ -120,6 +120,7 @@ protected void startToUpload() { currentRegionRequestMetrics.start(); } + @Deprecated protected boolean switchRegionAndUpload() { if (currentRegionRequestMetrics != null) { currentRegionRequestMetrics.end(); @@ -209,12 +210,25 @@ protected boolean switchRegion() { protected boolean switchRegionAndUploadIfNeededWithErrorResponse(ResponseInfo errorResponseInfo) { if (errorResponseInfo == null || errorResponseInfo.isOK() || // 不存在 || 不是error 不切 - !errorResponseInfo.couldRetry() || !config.allowBackupHost || // 不能重试不切 - !switchRegionAndUpload()) { // 切换失败 + !errorResponseInfo.couldRetry() || !config.allowBackupHost) { // 不能重试 + return false; + } + + if (currentRegionRequestMetrics != null) { + currentRegionRequestMetrics.end(); + metrics.addMetrics(currentRegionRequestMetrics); + currentRegionRequestMetrics = null; + } + + // 切换区域，当为 context 过期错误不需要切换区域 + if (!errorResponseInfo.isCtxExpiredError() && !switchRegion()) { + // 非 context 过期错误，但是切换 region 失败 return false; - } else { - return true; } + + startToUpload(); + + return true; } protected IUploadRegion getTargetRegion() { diff --git a/library/src/main/java/com/qiniu/android/storage/PartsUpload.java b/library/src/main/java/com/qiniu/android/storage/PartsUpload.java index 5afbfe867..e482e7334 100644 --- a/library/src/main/java/com/qiniu/android/storage/PartsUpload.java +++ b/library/src/main/java/com/qiniu/android/storage/PartsUpload.java @@ -109,9 +109,9 @@ protected boolean switchRegion() { } @Override - protected boolean switchRegionAndUpload() { + protected boolean switchRegionAndUploadIfNeededWithErrorResponse(ResponseInfo errorResponseInfo) { reportBlock(); - return super.switchRegionAndUpload(); + return super.switchRegionAndUploadIfNeededWithErrorResponse(errorResponseInfo); } @Override diff --git a/library/src/main/java/com/qiniu/android/storage/UploadBlock.java b/library/src/main/java/com/qiniu/android/storage/UploadBlock.java index 930c58835..6b1946b12 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadBlock.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadBlock.java @@ -1,5 +1,7 @@ package com.qiniu.android.storage; +import com.qiniu.android.utils.Utils; + import org.json.JSONArray; import org.json.JSONObject; @@ -13,6 +15,9 @@ class UploadBlock { final int index; final List uploadDataList; + // 单位：秒 + Long expireAt = null; + String md5 = null; String ctx = null; @@ -38,6 +43,7 @@ static UploadBlock blockFromJson(JSONObject jsonObject) throws Exception { long offset = jsonObject.getLong("offset"); int size = jsonObject.getInt("size"); int index = jsonObject.getInt("index"); + long expireAt = jsonObject.getLong("expired_at"); String md5 = jsonObject.optString("md5"); String ctx = jsonObject.optString("ctx"); ArrayList uploadDataList = new ArrayList(); @@ -51,11 +57,22 @@ static UploadBlock blockFromJson(JSONObject jsonObject) throws Exception { } UploadBlock block = new UploadBlock(offset, size, index, uploadDataList); + block.expireAt = expireAt; block.md5 = md5; block.ctx = ctx; return block; } + boolean isValid() { + if (expireAt == null || expireAt == 0) { + // 不存在时，为新创建 block: 有效 + return true; + } + + // 存在则有效期必须为过期 + return (expireAt - 3600 * 24) > Utils.currentSecondTimestamp(); + } + boolean isCompleted() { if (uploadDataList == null) { return true; @@ -107,6 +124,7 @@ JSONObject toJsonObject() throws Exception { jsonObject.putOpt("offset", offset); jsonObject.putOpt("size", size); jsonObject.putOpt("index", index); + jsonObject.putOpt("expired_at", expireAt); jsonObject.putOpt("md5", md5); jsonObject.putOpt("ctx", ctx); if (uploadDataList != null && uploadDataList.size() > 0) { diff --git a/library/src/main/java/com/qiniu/android/storage/UploadInfoV1.java b/library/src/main/java/com/qiniu/android/storage/UploadInfoV1.java index be881ebc2..d3d0685ae 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadInfoV1.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadInfoV1.java @@ -83,6 +83,27 @@ boolean isFirstData(UploadData data) { return data.index == 0; } + @Override + boolean isValid() { + if (!super.isValid()) { + return false; + } + + final boolean[] isValid = {true}; + blockList.enumerateObjects(new ListVector.EnumeratorHandler() { + @Override + public boolean enumerate(UploadBlock block) { + boolean valid = block.isValid(); + if (!valid) { + isValid[0] = false; + return true; + } + return false; + } + }); + return isValid[0]; + } + @Override boolean reloadSource() { isEOF = false; diff --git a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java index f2100a87c..8755bcf88 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java @@ -3,6 +3,7 @@ import com.qiniu.android.utils.ListVector; import com.qiniu.android.utils.MD5; import com.qiniu.android.utils.StringUtils; +import com.qiniu.android.utils.Utils; import org.json.JSONArray; import org.json.JSONObject; @@ -293,8 +294,7 @@ boolean isValid() { return false; } - long timestamp = new Date().getTime() / 1000; - return expireAt > (timestamp - 3600 * 24 * 2); + return (expireAt - 3600 * 24) > Utils.currentSecondTimestamp(); } // 文件已经读取结束 & 所有片均上传 From 5e9d13889179c5a9466995b5be6d7e58e0ae992a Mon Sep 17 00:00:00 2001 From: yangsen Date: Fri, 23 Sep 2022 15:00:03 +0800 Subject: [PATCH 05/12] Configuration add writeTimeout --- gradle/wrapper/gradle-wrapper.properties | 4 ++-- .../http/request/HttpRegionRequest.java | 5 +++- .../qiniu/android/http/request/Request.java | 23 ++++++++++++++++--- .../request/httpclient/SystemHttpClient.java | 6 ++--- .../qiniu/android/storage/Configuration.java | 21 +++++++++++++---- .../storage/PartsUploadPerformerV1.java | 7 ++++-- 6 files changed, 51 insertions(+), 15 deletions(-) diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 078b8e4e3..625241916 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Thu Jul 28 11:54:47 CST 2022 +#Tue Sep 20 17:18:12 CST 2022 distributionBase=GRADLE_USER_HOME -distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip distributionPath=wrapper/dists zipStorePath=wrapper/dists zipStoreBase=GRADLE_USER_HOME diff --git a/library/src/main/java/com/qiniu/android/http/request/HttpRegionRequest.java b/library/src/main/java/com/qiniu/android/http/request/HttpRegionRequest.java index 3ab6810d0..46933a532 100644 --- a/library/src/main/java/com/qiniu/android/http/request/HttpRegionRequest.java +++ b/library/src/main/java/com/qiniu/android/http/request/HttpRegionRequest.java @@ -108,7 +108,10 @@ private void performRequest(final IUploadServer server, String scheme = config.useHttps ? "https://" : "http://"; String urlString = scheme + serverHost + (action != null ? action : ""); - final Request request = new Request(urlString, method, header, data, config.connectTimeout); + final Request request = new Request(urlString, method, header, data, + config.connectTimeout, + config.writeTimeout, + config.responseTimeout); request.setHost(serverHost); LogUtil.i("key:" + StringUtils.toNonnullString(requestInfo.key) + " url:" + StringUtils.toNonnullString(request.urlString)); diff --git a/library/src/main/java/com/qiniu/android/http/request/Request.java b/library/src/main/java/com/qiniu/android/http/request/Request.java index d60446c64..4b6298cfc 100644 --- a/library/src/main/java/com/qiniu/android/http/request/Request.java +++ b/library/src/main/java/com/qiniu/android/http/request/Request.java @@ -1,6 +1,5 @@ package com.qiniu.android.http.request; -import java.net.InetAddress; import java.util.HashMap; import java.util.Map; @@ -15,6 +14,9 @@ public class Request { public final String httpMethod; public final Map allHeaders; public final int timeout; + public final int connectTimeout; + public final int readTimeout; + public final int writeTimeout; public byte[] httpBody; private String host; @@ -24,12 +26,27 @@ public Request(String urlString, Map allHeaders, byte[] httpBody, int timeout) { + this(urlString, httpMethod, allHeaders, httpBody, 10, + (int) ((timeout - 10) * 0.5), + (int) ((timeout - 10) * 0.5)); + } + + public Request(String urlString, + String httpMethod, + Map allHeaders, + byte[] httpBody, + int connectTimeout, + int readTimeout, + int writeTimeout) { this.urlString = urlString; this.httpMethod = (httpMethod != null) ? httpMethod : HttpMethodGet; this.allHeaders = (allHeaders != null) ? allHeaders : new HashMap(); - this.httpBody = (httpBody != null) ? httpBody : new byte[0]; - this.timeout = timeout; + this.httpBody = (httpBody != null) ? httpBody : new byte[0]; + this.connectTimeout = connectTimeout; + this.readTimeout = readTimeout; + this.writeTimeout = writeTimeout; + this.timeout = connectTimeout + writeTimeout + readTimeout; } void setHost(String host) { diff --git a/library/src/main/java/com/qiniu/android/http/request/httpclient/SystemHttpClient.java b/library/src/main/java/com/qiniu/android/http/request/httpclient/SystemHttpClient.java index 2be80606b..a01eb13d7 100644 --- a/library/src/main/java/com/qiniu/android/http/request/httpclient/SystemHttpClient.java +++ b/library/src/main/java/com/qiniu/android/http/request/httpclient/SystemHttpClient.java @@ -206,9 +206,9 @@ public List lookup(String s) throws UnknownHostException { clientBuilder.connectionPool(SystemHttpClient.getConnectPool()); - clientBuilder.connectTimeout(currentRequest.timeout, TimeUnit.SECONDS); - clientBuilder.readTimeout(currentRequest.timeout, TimeUnit.SECONDS); - clientBuilder.writeTimeout(60, TimeUnit.SECONDS); + clientBuilder.connectTimeout(currentRequest.connectTimeout, TimeUnit.SECONDS); + clientBuilder.readTimeout(currentRequest.readTimeout, TimeUnit.SECONDS); + clientBuilder.writeTimeout(currentRequest.writeTimeout, TimeUnit.SECONDS); return clientBuilder.build(); } diff --git a/library/src/main/java/com/qiniu/android/storage/Configuration.java b/library/src/main/java/com/qiniu/android/storage/Configuration.java index 540d7b023..cd4aa651b 100644 --- a/library/src/main/java/com/qiniu/android/storage/Configuration.java +++ b/library/src/main/java/com/qiniu/android/storage/Configuration.java @@ -50,13 +50,19 @@ public final class Configuration { public final int retryInterval; /** - * 连接超时时间 单位 秒 + * 连接超时时间 单位 秒，默认：10 * 注：每个文件上传肯能存在多个操作，当每个操作失败时，可能存在多个请求重试。 */ public final int connectTimeout; /** - * 服务器响应超时时间 单位 秒 + * write 响应超时时间 单位 秒，默认：30 + * 注：每个文件上传肯能存在多个操作，当每个操作失败时，可能存在多个请求重试。 + */ + public final int writeTimeout; + + /** + * 服务器响应超时时间，对应到 readTimeout 单位 秒，默认：10 * 注：每个文件上传肯能存在多个操作，当每个操作失败时，可能存在多个请求重试。 */ public final int responseTimeout; @@ -133,6 +139,7 @@ private Configuration(Builder builder) { putThreshold = builder.putThreshold; connectTimeout = builder.connectTimeout; + writeTimeout = builder.writeTimeout; responseTimeout = builder.responseTimeout; recorder = builder.recorder; @@ -182,8 +189,9 @@ public static class Builder { private boolean useHttps = true; private int chunkSize = 2 * 1024 * 1024; private int putThreshold = 4 * 1024 * 1024; - private int connectTimeout = 20; - private int responseTimeout = 60; + private int connectTimeout = 10; + private int writeTimeout = 30; + private int responseTimeout = 10; private int retryMax = 1; private int retryInterval = 500; private boolean allowBackupHost = true; @@ -233,6 +241,11 @@ public Builder connectTimeout(int timeout) { return this; } + public Builder writeTimeout(int timeout) { + this.writeTimeout = timeout; + return this; + } + public Builder responseTimeout(int timeout) { this.responseTimeout = timeout; return this; diff --git a/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformerV1.java b/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformerV1.java index 9a610afc2..908655677 100644 --- a/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformerV1.java +++ b/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformerV1.java @@ -99,14 +99,17 @@ public void progress(long totalBytesWritten, long totalBytesExpectedToWrite) { public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics requestMetrics, JSONObject response) { String ctx = null; + Long expiredAt = null; if (response != null) { try { ctx = response.getString("ctx"); + expiredAt = response.getLong("expired_at"); } catch (JSONException e) { } } - if (responseInfo.isOK() && ctx != null) { + if (responseInfo.isOK() && ctx != null && expiredAt != null) { uploadBlock.ctx = ctx; + uploadBlock.expireAt = expiredAt; uploadChunk.updateState(UploadData.State.Complete); recordUploadInfo(); notifyProgress(false); @@ -121,7 +124,7 @@ public void complete(ResponseInfo responseInfo, UploadRegionRequestMetrics reque LogUtil.i("key:" + StringUtils.toNonnullString(key) + " makeBlock"); makeBlock(uploadBlock, uploadChunk, progressHandler, completeHandlerP); } else { - LogUtil.i("key:" + StringUtils.toNonnullString(key) + " makeBlock"); + LogUtil.i("key:" + StringUtils.toNonnullString(key) + " uploadChunk"); uploadChunk(uploadBlock, uploadChunk, progressHandler, completeHandlerP); } } From 8acc480494de277f2cee8a5c9abeea58b5e9ee1c Mon Sep 17 00:00:00 2001 From: yangsen Date: Wed, 28 Sep 2022 15:42:13 +0800 Subject: [PATCH 06/12] resume upload, handle 612 (no such upload id) --- .../com/qiniu/android/http/ResponseInfo.java | 48 +++++++++++++++---- .../com/qiniu/android/storage/BaseUpload.java | 9 ++++ .../qiniu/android/storage/PartsUpload.java | 15 ++++-- .../android/storage/PartsUploadPerformer.java | 10 ++-- .../qiniu/android/storage/UploadInfoV2.java | 2 + 5 files changed, 66 insertions(+), 18 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java index d7df7a9b1..e47bacb25 100644 --- a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java +++ b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java @@ -17,7 +17,7 @@ public final class ResponseInfo { /** * StatusCode >= 100 见：https://developer.qiniu.com/kodo/3928/error-responses */ - + @Deprecated public static final int ResquestSuccess = 200; @@ -36,7 +36,7 @@ public final class ResponseInfo { /** * 在上传时，SDK 内部业务逻辑非预期。正常情况下，此错误并会被抛掷应用层。 - * + *

* 此错误出现的原因一般为某个上传流程异常请求导致，实际应该抛出请求，但因为调用异常未被抛出。 */ public static final int SDKInteriorError = -9; @@ -335,14 +335,22 @@ public boolean isOK() { } public boolean couldRetry() { - if (isQiniu() && (isCancelled() + if (isNotQiniu()) { + return true; + } + + if (isCtxExpiredError()) { + return true; + } + + if (isCancelled() + || statusCode == 100 || (statusCode > 300 && statusCode < 400) || (statusCode > 400 && statusCode < 500 && statusCode != 406) || statusCode == 501 || statusCode == 573 || statusCode == 608 || statusCode == 612 || statusCode == 614 || statusCode == 616 || statusCode == 619 || statusCode == 630 || statusCode == 631 || statusCode == 640 - || statusCode == 701 - || (statusCode < -1 && statusCode > -1000))) { + || (statusCode < -1 && statusCode > -1000)) { return false; } else { return true; @@ -350,7 +358,18 @@ public boolean couldRetry() { } public boolean couldRegionRetry() { - if (!couldRetry() || statusCode == 400 || statusCode == 579) { + if (isNotQiniu()) { + return true; + } + + if (isCancelled() + || statusCode == 100 + || (statusCode > 300 && statusCode < 500 && statusCode != 406) + || statusCode == 501 || statusCode == 573 || statusCode == 579 + || statusCode == 608 || statusCode == 612 || statusCode == 614 || statusCode == 616 + || statusCode == 619 || statusCode == 630 || statusCode == 631 || statusCode == 640 + || statusCode == 701 + || (statusCode < -1 && statusCode > -1000)) { return false; } else { return true; @@ -358,8 +377,19 @@ public boolean couldRegionRetry() { } public boolean couldHostRetry() { - if (isNotQiniu() || !couldRegionRetry() || statusCode == 502 || statusCode == 503 || - statusCode == 571 || statusCode == 599) { + if (isNotQiniu()) { + return true; + } + + if (isCancelled() + || statusCode == 100 + || (statusCode > 300 && statusCode < 500 && statusCode != 406) + || statusCode == 501 || statusCode == 502 || statusCode == 503 + || statusCode == 571 || statusCode == 573 || statusCode == 579 || statusCode == 599 + || statusCode == 608 || statusCode == 612 || statusCode == 614 || statusCode == 616 + || statusCode == 619 || statusCode == 630 || statusCode == 631 || statusCode == 640 + || statusCode == 701 + || (statusCode < -1 && statusCode > -1000)) { return false; } else { return true; @@ -393,7 +423,7 @@ public boolean isHostUnavailable() { // 在断点续上传过程中，ctx 信息已过期。 public boolean isCtxExpiredError() { - return statusCode == 701; + return statusCode == 701 || (statusCode == 612 && error != null && error.contains("no such uploadId")); } public boolean isNetworkBroken() { diff --git a/library/src/main/java/com/qiniu/android/storage/BaseUpload.java b/library/src/main/java/com/qiniu/android/storage/BaseUpload.java index d109a06a7..26b074b48 100644 --- a/library/src/main/java/com/qiniu/android/storage/BaseUpload.java +++ b/library/src/main/java/com/qiniu/android/storage/BaseUpload.java @@ -107,6 +107,10 @@ public void complete(int code, ResponseInfo responseInfo, UploadRegionRequestMet }); } + protected boolean reloadUploadInfo() { + return true; + } + protected int prepareToUpload() { int ret = 0; if (!setupRegions()) { @@ -220,6 +224,11 @@ protected boolean switchRegionAndUploadIfNeededWithErrorResponse(ResponseInfo er currentRegionRequestMetrics = null; } + // 重新加载上传数据，上传记录 & Resource index 归零 + if (!reloadUploadInfo()) { + return false; + } + // 切换区域，当为 context 过期错误不需要切换区域 if (!errorResponseInfo.isCtxExpiredError() && !switchRegion()) { // 非 context 过期错误，但是切换 region 失败 diff --git a/library/src/main/java/com/qiniu/android/storage/PartsUpload.java b/library/src/main/java/com/qiniu/android/storage/PartsUpload.java index e482e7334..14c580941 100644 --- a/library/src/main/java/com/qiniu/android/storage/PartsUpload.java +++ b/library/src/main/java/com/qiniu/android/storage/PartsUpload.java @@ -93,11 +93,6 @@ protected int prepareToUpload() { @Override protected boolean switchRegion() { - // 重新加载资源，如果加载失败，不可切换 region - if (!uploadPerformer.couldReloadInfo() || !uploadPerformer.reloadInfo()) { - return false; - } - boolean isSuccess = super.switchRegion(); if (isSuccess) { uploadPerformer.switchRegion(getCurrentRegion()); @@ -114,6 +109,16 @@ protected boolean switchRegionAndUploadIfNeededWithErrorResponse(ResponseInfo er return super.switchRegionAndUploadIfNeededWithErrorResponse(errorResponseInfo); } + @Override + protected boolean reloadUploadInfo() { + if (!super.reloadUploadInfo()) { + return false; + } + + // 重新加载资源 + return uploadPerformer.couldReloadInfo() && uploadPerformer.reloadInfo(); + } + @Override protected void startToUpload() { super.startToUpload(); diff --git a/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformer.java b/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformer.java index de7c5917f..8e4b9f0ee 100644 --- a/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformer.java +++ b/library/src/main/java/com/qiniu/android/storage/PartsUploadPerformer.java @@ -72,6 +72,12 @@ boolean couldReloadInfo() { } boolean reloadInfo() { + if (uploadInfo == null) { + return false; + } + + recoveredFrom = null; + uploadInfo.clearUploadState(); return uploadInfo.reloadSource(); } @@ -82,11 +88,7 @@ void closeFile() { } void switchRegion(IUploadRegion region) { - if (uploadInfo != null) { - uploadInfo.clearUploadState(); - } currentRegion = region; - recoveredFrom = null; if (targetRegion == null) { targetRegion = region; } diff --git a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java index 8755bcf88..289a69b9e 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java @@ -259,6 +259,8 @@ boolean isSameUploadInfo(UploadInfo info) { @Override void clearUploadState() { + expireAt = null; + uploadId = null; dataList.enumerateObjects(new ListVector.EnumeratorHandler() { @Override public boolean enumerate(UploadData data) { From d7769e22901eedbad8ccff6d5157e465fe92b6e7 Mon Sep 17 00:00:00 2001 From: yangsen Date: Wed, 28 Sep 2022 15:44:15 +0800 Subject: [PATCH 07/12] update test token --- .../java/com/qiniu/android/TestConfig.java | 20 ++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/library/src/androidTest/java/com/qiniu/android/TestConfig.java b/library/src/androidTest/java/com/qiniu/android/TestConfig.java index 15bb01a4c..3c514aa82 100644 --- a/library/src/androidTest/java/com/qiniu/android/TestConfig.java +++ b/library/src/androidTest/java/com/qiniu/android/TestConfig.java @@ -8,22 +8,28 @@ */ public final class TestConfig { // TODO: 2020-05-09 bad token for testPutBytesWithFixedZoneUseBackupDomains -// 华东上传凭证 + // 华东上传凭证 public static final String bucket_z0 = "kodo-phone-zone0-space"; - public static final String token_z0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:Roi8S7DgfHIFPMcAumjwfUjK5ks=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTAtc3BhY2UiLCJkZWFkbGluZSI6MTY2MzQ5MzQ1NywgInJldHVybkJvZHkiOiJ7XCJjYWxsYmFja1VybFwiOlwiaHR0cDpcL1wvY2FsbGJhY2suZGV2LnFpbml1LmlvXCIsIFwiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + public static final String token_z0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:Qxeb7v5PXIrih_gwR-6pD1KsGgg=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTAtc3BhY2UiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; // 华北上传凭证 public static final String bucket_z1 = "kodo-phone-zone1-space"; - public static final String token_z1 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:n7jlhOqM2C8z_S9euP-z8GOV6kI=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTEtc3BhY2UiLCJkZWFkbGluZSI6MTY2MzQ5MzQ1NywgInJldHVybkJvZHkiOiJ7XCJjYWxsYmFja1VybFwiOlwiaHR0cDpcL1wvY2FsbGJhY2suZGV2LnFpbml1LmlvXCIsIFwiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + public static final String token_z1 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:crF2Xi7Zxcs6y9OIwmbZ_9QdAtA=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTEtc3BhY2UiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; // 华南上传凭证 public static final String bucket_z2 = "kodo-phone-zone2-space"; - public static final String token_z2 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:iOhhxgB-Qg2Xk1DE5a8iBv2Km2A=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTItc3BhY2UiLCJkZWFkbGluZSI6MTY2MzQ5MzQ1NywgInJldHVybkJvZHkiOiJ7XCJjYWxsYmFja1VybFwiOlwiaHR0cDpcL1wvY2FsbGJhY2suZGV2LnFpbml1LmlvXCIsIFwiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + public static final String token_z2 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:leoDnGLMa0wfqQ4GGb3yqWjLw5Y=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZTItc3BhY2UiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; // 北美上传凭证 public static final String bucket_na0 = "kodo-phone-zone-na0-space"; - public static final String token_na0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:iNjOiABc2l6MehUUzNWfmuVMcZk=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZS1uYTAtc3BhY2UiLCJkZWFkbGluZSI6MTY2MzQ5MzQ1NywgInJldHVybkJvZHkiOiJ7XCJjYWxsYmFja1VybFwiOlwiaHR0cDpcL1wvY2FsbGJhY2suZGV2LnFpbml1LmlvXCIsIFwiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + public static final String token_na0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:4WqbwsnKFgWO6vZMr8V6tVMNZ50=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZS1uYTAtc3BhY2UiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; // 东南亚上传凭证 public static final String bucket_as0 = "kodo-phone-zone-as0-space"; - public static final String token_as0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:BmIVBf3N0ubrYXqLUkGc4yGNHKE=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZS1hczAtc3BhY2UiLCJkZWFkbGluZSI6MTY2MzQ5MzQ1NywgInJldHVybkJvZHkiOiJ7XCJjYWxsYmFja1VybFwiOlwiaHR0cDpcL1wvY2FsbGJhY2suZGV2LnFpbml1LmlvXCIsIFwiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; - public static final String invalidBucketToken = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:qO7aqfczyqxOOsm6uwyz6AAuCh0=:eyJzY29wZSI6InpvbmVfaW52YWxpZCIsImRlYWRsaW5lIjoxNjYzNDkzNDU3LCAicmV0dXJuQm9keSI6IntcImNhbGxiYWNrVXJsXCI6XCJodHRwOlwvXC9jYWxsYmFjay5kZXYucWluaXUuaW9cIiwgXCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; + public static final String token_as0 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:YjOnS0SLd0P1Z5VG_3Oxfls0KeA=:eyJzY29wZSI6ImtvZG8tcGhvbmUtem9uZS1hczAtc3BhY2UiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; + // 华北浙江2上传凭证 + public static final String bucket_cn_east_2 = "kodo-phone-cn-east-2"; + public static final String token_cn_east_2 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:ogrnSltO4Vdsrcsk4XNCR9t63tQ=:eyJzY29wZSI6ImtvZG8tcGhvbmUtY24tZWFzdC0yIiwiZGVhZGxpbmUiOjE2Njk1MzQ5NzgsICJyZXR1cm5Cb2R5Ijoie1wiZm9vXCI6JCh4OmZvbyksIFwiYmFyXCI6JCh4OmJhciksIFwibWltZVR5cGVcIjokKG1pbWVUeXBlKSwgXCJoYXNoXCI6JChldGFnKSwgXCJrZXlcIjokKGtleSksIFwiZm5hbWVcIjokKGZuYW1lKX0ifQ=="; + // 韩国亚太上传凭证 + public static final String bucket_ap_northeast_1 = "kodo-phone-ap-northeast-1"; + public static final String token_ap_northeast_1 = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:yI8KG27WvY9QSLv669-yv9Ac1mY=:eyJzY29wZSI6ImtvZG8tcGhvbmUtYXAtbm9ydGhlYXN0LTEiLCJkZWFkbGluZSI6MTY2OTUzNDk3OCwgInJldHVybkJvZHkiOiJ7XCJmb29cIjokKHg6Zm9vKSwgXCJiYXJcIjokKHg6YmFyKSwgXCJtaW1lVHlwZVwiOiQobWltZVR5cGUpLCBcImhhc2hcIjokKGV0YWcpLCBcImtleVwiOiQoa2V5KSwgXCJmbmFtZVwiOiQoZm5hbWUpfSJ9"; + public static final String invalidBucketToken = "dxVQk8gyk3WswArbNhdKIwmwibJ9nFsQhMNUmtIM:KVBTuAcbmqx0ji81VQRwPzLgUEY=:eyJzY29wZSI6InpvbmVfaW52YWxpZCIsImRlYWRsaW5lIjoxNjY5NTM0OTc4LCAicmV0dXJuQm9keSI6IntcImZvb1wiOiQoeDpmb28pLCBcImJhclwiOiQoeDpiYXIpLCBcIm1pbWVUeXBlXCI6JChtaW1lVHlwZSksIFwiaGFzaFwiOiQoZXRhZyksIFwia2V5XCI6JChrZXkpLCBcImZuYW1lXCI6JChmbmFtZSl9In0="; // ----------- public static final String ak = "bjtWBQXrcxgo7HWwlC_bgHg81j352_GhgBGZPeOW"; From 1d53a31535c17c75ba67ba87a09506ffc6b0192e Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 29 Sep 2022 14:32:47 +0800 Subject: [PATCH 08/12] change ctx expireAt: -2h --- .../src/main/java/com/qiniu/android/storage/UploadBlock.java | 2 +- .../src/main/java/com/qiniu/android/storage/UploadInfoV2.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/storage/UploadBlock.java b/library/src/main/java/com/qiniu/android/storage/UploadBlock.java index 6b1946b12..1c9e7a8ef 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadBlock.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadBlock.java @@ -70,7 +70,7 @@ boolean isValid() { } // 存在则有效期必须为过期 - return (expireAt - 3600 * 24) > Utils.currentSecondTimestamp(); + return (expireAt - 2 * 3600) > Utils.currentSecondTimestamp(); } boolean isCompleted() { diff --git a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java index 289a69b9e..a1628e029 100644 --- a/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java +++ b/library/src/main/java/com/qiniu/android/storage/UploadInfoV2.java @@ -296,7 +296,7 @@ boolean isValid() { return false; } - return (expireAt - 3600 * 24) > Utils.currentSecondTimestamp(); + return (expireAt - 2 * 3600) > Utils.currentSecondTimestamp(); } // 文件已经读取结束 & 所有片均上传 From 54a85a77d5214ae7fdabe3424617faa3007178af Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 29 Sep 2022 15:05:53 +0800 Subject: [PATCH 09/12] change some note --- library/src/main/java/com/qiniu/android/common/Config.java | 6 +++--- .../src/main/java/com/qiniu/android/http/ResponseInfo.java | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/common/Config.java b/library/src/main/java/com/qiniu/android/common/Config.java index f60545cb0..d792f4209 100644 --- a/library/src/main/java/com/qiniu/android/common/Config.java +++ b/library/src/main/java/com/qiniu/android/common/Config.java @@ -16,7 +16,7 @@ public final class Config { * 记录上传信息条件： * isRecord 为 true, * 记录文件大小 小于 maxRecordFileSize . - *

+ *

* 记录文件大小 大于 maxRecordFileSize 时, 则暂停记录信息。 */ public static boolean isRecord = true; @@ -28,7 +28,7 @@ public final class Config { * isRecord 为 true, isUpload 为 true, * 且 记录文件大小 大于 uploadThreshold, * 且 距上次上传时间大于 minInteval . - *

+ *

* 上传成功后，清空记录文件文件 */ public static boolean isUpload = true; @@ -49,7 +49,7 @@ public final class Config { /** * 记录上传信息文件最大值，单位：字节。 - *

+ * * 记录文件大于此值后暂停记录上传信息。 */ public static int maxRecordFileSize = 20 * 1024 * 1024; diff --git a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java index e47bacb25..780ac6802 100644 --- a/library/src/main/java/com/qiniu/android/http/ResponseInfo.java +++ b/library/src/main/java/com/qiniu/android/http/ResponseInfo.java @@ -36,7 +36,7 @@ public final class ResponseInfo { /** * 在上传时，SDK 内部业务逻辑非预期。正常情况下，此错误并会被抛掷应用层。 - *

+ * * 此错误出现的原因一般为某个上传流程异常请求导致，实际应该抛出请求，但因为调用异常未被抛出。 */ public static final int SDKInteriorError = -9; From 3ab2c892a23bc2e5ffcf23d91e2e26f12914343d Mon Sep 17 00:00:00 2001 From: yangsen Date: Thu, 29 Sep 2022 15:39:48 +0800 Subject: [PATCH 10/12] optimize code: Request --- .../src/main/java/com/qiniu/android/http/request/Request.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/http/request/Request.java b/library/src/main/java/com/qiniu/android/http/request/Request.java index 4b6298cfc..f5556f880 100644 --- a/library/src/main/java/com/qiniu/android/http/request/Request.java +++ b/library/src/main/java/com/qiniu/android/http/request/Request.java @@ -27,8 +27,8 @@ public Request(String urlString, byte[] httpBody, int timeout) { this(urlString, httpMethod, allHeaders, httpBody, 10, - (int) ((timeout - 10) * 0.5), - (int) ((timeout - 10) * 0.5)); + (timeout - 10) >> 1, + (timeout - 10) >> 1); } public Request(String urlString, From 9e1c7fcbacef2aa05e5f40e61de69474bc7b6263 Mon Sep 17 00:00:00 2001 From: yangsen Date: Fri, 30 Sep 2022 18:01:43 +0800 Subject: [PATCH 11/12] change Request use method --- .../qiniu/android/http/connectCheck/ConnectChecker.java | 3 ++- .../android/http/metrics/UploadSingleRequestMetrics.java | 3 ++- .../java/com/qiniu/android/http/request/Request.java | 9 +++++++++ 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/library/src/main/java/com/qiniu/android/http/connectCheck/ConnectChecker.java b/library/src/main/java/com/qiniu/android/http/connectCheck/ConnectChecker.java index 3cb9bd9c6..a6a405fab 100644 --- a/library/src/main/java/com/qiniu/android/http/connectCheck/ConnectChecker.java +++ b/library/src/main/java/com/qiniu/android/http/connectCheck/ConnectChecker.java @@ -129,7 +129,8 @@ public Object call() throws Exception { } }, timeout, TimeUnit.SECONDS); - Request request = new Request(host, Request.HttpMethodHEAD, null, null, timeout); + Request request = new Request(host, Request.HttpMethodHEAD, null, null, + timeout, timeout, timeout); SystemHttpClient client = new SystemHttpClient(); LogUtil.i("== checkHost:" + host); diff --git a/library/src/main/java/com/qiniu/android/http/metrics/UploadSingleRequestMetrics.java b/library/src/main/java/com/qiniu/android/http/metrics/UploadSingleRequestMetrics.java index dfb17b2e5..4996d1b9a 100644 --- a/library/src/main/java/com/qiniu/android/http/metrics/UploadSingleRequestMetrics.java +++ b/library/src/main/java/com/qiniu/android/http/metrics/UploadSingleRequestMetrics.java @@ -65,7 +65,8 @@ public Request getRequest() { public void setRequest(Request request) { if (request != null) { - this.request = new Request(request.urlString, request.httpMethod, request.allHeaders, null, request.timeout); + this.request = new Request(request.urlString, request.httpMethod, request.allHeaders, null, + request.connectTimeout, request.readTimeout, request.writeTimeout); long headerLength = 0; long bodyLength = 0; diff --git a/library/src/main/java/com/qiniu/android/http/request/Request.java b/library/src/main/java/com/qiniu/android/http/request/Request.java index f5556f880..e902ed10e 100644 --- a/library/src/main/java/com/qiniu/android/http/request/Request.java +++ b/library/src/main/java/com/qiniu/android/http/request/Request.java @@ -38,6 +38,15 @@ public Request(String urlString, int connectTimeout, int readTimeout, int writeTimeout) { + if (connectTimeout < 0) { + connectTimeout = 10; + } + if (readTimeout < 0) { + readTimeout = 10; + } + if (writeTimeout < 0) { + writeTimeout = 30; + } this.urlString = urlString; this.httpMethod = (httpMethod != null) ? httpMethod : HttpMethodGet; From 853c5561cbdf6bd445e29d3f088809a9cc3c9d3e Mon Sep 17 00:00:00 2001 From: yangsen Date: Mon, 10 Oct 2022 10:54:26 +0800 Subject: [PATCH 12/12] UriTest add empty test case --- .../src/androidTest/java/com/qiniu/android/storage/UriTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java index 48f9c2b4b..7d0fd4b81 100644 --- a/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java +++ b/library/src/androidTest/java/com/qiniu/android/storage/UriTest.java @@ -44,6 +44,7 @@ public class UriTest extends BaseTest { {false, false, false}, }; + @Test public void test() { }