From: Rolf Bjarne Kvinge Date: Mon, 3 Oct 2016 11:00:16 +0000 (+0200) Subject: [System*] Throw a PlatformNotSupported exception when using the managed networking... X-Git-Url: http://wien.tomnetworks.com/gitweb/?p=mono.git;a=commitdiff_plain;h=5780d872ad5c32a1fcfa84c8e86af5ee73e50e9c [System*] Throw a PlatformNotSupported exception when using the managed networking stack on watchOS. (#3683) * [System.Data] System.Data.SqlClient is not supported in watchOS. System.Data.SqlClient is not supported in watchOS, because it depends on a working managed networking stack, which we don't have on watchOS. * [System] Throw PlatformNotSupportedExceptions in the networking stack for watchOS. * [System] Don't reference/build Mono.Security.dll when building for watchOS. This means we can't build Mono.Data.Tds.dll either, since it uses Mono.Security.dll extensively. In any case Mono.Data.Tds.dll is useless without a working networking stack, and since it's a Mono-only dll (i.e. not part of netstandard or facades), just remove the entire assembly from the watchOS profile. System.Security.dll uses Mono.Security.dll as well, but the required classes are available inside mscorlib.dll (as internal classes), so just open up mscorlib internals to System.Security.dll. * [System] Update tests after API change for watchOS. * [System.Data] Update tests after API change in watchOS. * Revert "Fix build break from 81fb20737f810def6dde88d87a1b2f23cdb736c3" This reverts commit f4475ff01358f8490e7cd0878e8b39bed2a0def7. * Fix missing trailing newline in monotouch_watch_System.dll.sources It breaks the build on Linux if the newline is missing. --- diff --git a/mcs/build/profiles/monotouch_watch.make b/mcs/build/profiles/monotouch_watch.make index 02c934b62e6..4bba2f421ac 100644 --- a/mcs/build/profiles/monotouch_watch.make +++ b/mcs/build/profiles/monotouch_watch.make @@ -8,3 +8,4 @@ NO_THREAD_ABORT=1 NO_THREAD_SUSPEND_RESUME=1 NO_MULTIPLE_APPDOMAINS=1 NO_PROCESS_START=1 +NO_MONO_SECURITY=1 diff --git a/mcs/build/profiles/monotouch_watch_runtime.make b/mcs/build/profiles/monotouch_watch_runtime.make index cb6bf304b99..e826c7e7e31 100644 --- a/mcs/build/profiles/monotouch_watch_runtime.make +++ b/mcs/build/profiles/monotouch_watch_runtime.make @@ -9,3 +9,4 @@ NO_THREAD_SUSPEND_RESUME=1 # The binding generator (bwatch) still needs to execute processes, # so we need a System.dll that can do that. #NO_PROCESS_START=1 +NO_MONO_SECURITY=1 diff --git a/mcs/class/Makefile b/mcs/class/Makefile index ef78dfed837..f8f0b0a9396 100644 --- a/mcs/class/Makefile +++ b/mcs/class/Makefile @@ -83,7 +83,7 @@ monodroid_dirs := \ monotouch_dirs := \ $(mobile_static_dirs) -monotouch_watch_dirs := $(monotouch_dirs) +monotouch_watch_dirs := $(filter-out Mono.Security Mono.Data.Tds,$(monotouch_dirs)) monotouch_tv_dirs := $(monotouch_dirs) monotouch_runtime_dirs := \ @@ -94,7 +94,7 @@ monotouch_runtime_dirs := \ System.XML \ Mono.CSharp -monotouch_watch_runtime_dirs := $(monotouch_runtime_dirs) +monotouch_watch_runtime_dirs := $(filter-out Mono.Security Mono.Data.Tds,$(monotouch_runtime_dirs)) monotouch_tv_runtime_dirs := $(monotouch_runtime_dirs) xammac_4_5_dirs := \ diff --git a/mcs/class/System.Data/Makefile b/mcs/class/System.Data/Makefile index 39e46838503..e8a641299b3 100644 --- a/mcs/class/System.Data/Makefile +++ b/mcs/class/System.Data/Makefile @@ -12,11 +12,17 @@ LIB_MCS_FLAGS = \ -d:MONO_PARTIAL_DATA_IMPORT \ -unsafe +ifdef NO_MONO_SECURITY +MONO_DATA_TDS= +else +MONO_DATA_TDS=Mono.Data.Tds +endif + ifdef MOBILE_PROFILE -LIB_REFS += Mono.Data.Tds System.Transactions +LIB_REFS += $(MONO_DATA_TDS) System.Transactions LIB_MCS_FLAGS += -d:NO_CODEDOM -d:NO_OLEDB -d:NO_ODBC -d:NO_CONFIGURATION else -LIB_REFS += System.EnterpriseServices Mono.Data.Tds System.Configuration System.Transactions +LIB_REFS += System.EnterpriseServices $(MONO_DATA_TDS) System.Configuration System.Transactions BUILT_SOURCES = \ gen_OdbcConnection.cs \ gen_OleDbConnection.cs \ diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlBulkCopy.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlBulkCopy.platformnotsupported.cs new file mode 100644 index 00000000000..95d68018512 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlBulkCopy.platformnotsupported.cs @@ -0,0 +1,136 @@ +// +// SqlBulkCopy.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Data.Common; +using System.Threading; +using System.Threading.Tasks; + +namespace System.Data.SqlClient { + public sealed class SqlBulkCopy : IDisposable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlBulkCopy is not supported on the current platform."; + + public SqlBulkCopy (SqlConnection connection) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlBulkCopy (string connectionString) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlBulkCopy (string connectionString, SqlBulkCopyOptions copyOptions) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlBulkCopy (SqlConnection connection, SqlBulkCopyOptions copyOptions, SqlTransaction externalTransaction) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public int BatchSize { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int BulkCopyTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlBulkCopyColumnMappingCollection ColumnMappings { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string DestinationTableName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool EnableStreaming { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int NotifyAfter { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public void Close () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void WriteToServer (DataRow [] rows) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void WriteToServer (DataTable table) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void WriteToServer (IDataReader reader) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void WriteToServer (DataTable table, DataRowState rowState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void WriteToServer (DbDataReader reader) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public Task WriteToServerAsync (DbDataReader reader) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public Task WriteToServerAsync (DbDataReader reader, CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + private void RowsCopied (long rowsCopied) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public event SqlRowsCopiedEventHandler SqlRowsCopied; + + void IDisposable.Dispose () + { + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlCommand.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlCommand.platformnotsupported.cs new file mode 100644 index 00000000000..491483e1077 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlCommand.platformnotsupported.cs @@ -0,0 +1,277 @@ +// +// SqlCommand.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Data.Common; +using System.Data.Sql; +using System.Threading.Tasks; +using System.Threading; +using System.Xml; + +namespace System.Data.SqlClient { + public sealed class SqlCommand : DbCommand, IDbCommand, ICloneable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlCommand is not supported on the current platform."; + + public SqlCommand() + : this (String.Empty, null, null) + { + } + + public SqlCommand (string cmdText) + : this (cmdText, null, null) + { + } + + public SqlCommand (string cmdText, SqlConnection connection) + : this (cmdText, connection, null) + { + } + + public SqlCommand (string cmdText, SqlConnection connection, SqlTransaction transaction) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string CommandText { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int CommandTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override CommandType CommandType { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public new SqlConnection Connection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool DesignTimeVisible { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public new SqlParameterCollection Parameters { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public new SqlTransaction Transaction { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override UpdateRowSource UpdatedRowSource { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlNotificationRequest Notification { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool NotificationAutoEnlist { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override void Cancel () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand Clone () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new SqlParameter CreateParameter () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int ExecuteNonQuery () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new SqlDataReader ExecuteReader () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new SqlDataReader ExecuteReader (CommandBehavior behavior) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new Task ExecuteReaderAsync () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new Task ExecuteReaderAsync (CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new Task ExecuteReaderAsync (CommandBehavior behavior) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new Task ExecuteReaderAsync (CommandBehavior behavior, CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public Task ExecuteXmlReaderAsync () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public Task ExecuteXmlReaderAsync (CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override object ExecuteScalar () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public XmlReader ExecuteXmlReader () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + object ICloneable.Clone () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void Dispose (bool disposing) + { + } + + public override void Prepare () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void ResetCommandTimeout () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbParameter CreateDbParameter () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbDataReader ExecuteDbDataReader (CommandBehavior behavior) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbConnection DbConnection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + protected override DbParameterCollection DbParameterCollection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + protected override DbTransaction DbTransaction { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public IAsyncResult BeginExecuteNonQuery () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteNonQuery (AsyncCallback callback, object stateObject) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public int EndExecuteNonQuery (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteReader () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteReader (CommandBehavior behavior) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteReader (AsyncCallback callback, object stateObject) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteReader (AsyncCallback callback, object stateObject, CommandBehavior behavior) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlDataReader EndExecuteReader (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteXmlReader (AsyncCallback callback, object stateObject) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IAsyncResult BeginExecuteXmlReader () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public XmlReader EndExecuteXmlReader (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public event StatementCompletedEventHandler StatementCompleted; + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlCommandBuilder.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlCommandBuilder.platformnotsupported.cs new file mode 100644 index 00000000000..155ddabc197 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlCommandBuilder.platformnotsupported.cs @@ -0,0 +1,158 @@ +// +// SqlCommandBuilder.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Data; +using System.Data.Common; +using System.Data.SqlClient; + +namespace System.Data.SqlClient +{ + public class SqlCommandBuilder : DbCommandBuilder + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlCommandBuilder is not supported on the current platform."; + + public SqlCommandBuilder () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommandBuilder (SqlDataAdapter adapter) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void DeriveParameters (SqlCommand command) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetDeleteCommand () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetInsertCommand () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetUpdateCommand () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetUpdateCommand (bool useColumnsForParameterNames) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetDeleteCommand (bool useColumnsForParameterNames) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlCommand GetInsertCommand (bool useColumnsForParameterNames) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string QuoteIdentifier (string unquotedIdentifier) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string UnquoteIdentifier (string quotedIdentifier) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void ApplyParameterInfo (DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override string GetParameterName (int parameterOrdinal) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override string GetParameterName (string parameterName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override string GetParameterPlaceholder (int parameterOrdinal) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void SetRowUpdatingHandler (DbDataAdapter adapter) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DataTable GetSchemaTable (DbCommand srcCommand) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbCommand InitializeCommand (DbCommand command) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlDataAdapter DataAdapter { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string QuotePrefix { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string QuoteSuffix { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string CatalogSeparator { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string SchemaSeparator { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override CatalogLocation CatalogLocation { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlConnection.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlConnection.platformnotsupported.cs new file mode 100644 index 00000000000..bb350264499 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlConnection.platformnotsupported.cs @@ -0,0 +1,214 @@ +// +// SqlConnection.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Collections; +using System.Data.Common; + +namespace System.Data.SqlClient +{ + public sealed class SqlConnection : DbConnection, IDbConnection, ICloneable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlConnection is not supported on the current platform."; + + public SqlConnection () : this (null) + { + } + + public SqlConnection (string connectionString) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlConnection (string connectionString, SqlCredential cred) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string ConnectionString { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlCredential Credentials { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public Guid ClientConnectionId { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int ConnectionTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string Database { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string DataSource { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int PacketSize { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string ServerVersion { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override ConnectionState State { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string WorkstationId { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool FireInfoMessageEventOnUserErrors { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool StatisticsEnabled { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + protected override DbProviderFactory DbProviderFactory { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public event SqlInfoMessageEventHandler InfoMessage; + + public new SqlTransaction BeginTransaction () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new SqlTransaction BeginTransaction (IsolationLevel iso) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlTransaction BeginTransaction (string transactionName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlTransaction BeginTransaction (IsolationLevel iso, string transactionName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void ChangeDatabase (string database) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Close () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public new SqlCommand CreateCommand () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void Dispose (bool disposing) + { + } + +#if !MOBILE + public void EnlistDistributedTransaction (ITransaction transaction) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } +#endif + + object ICloneable.Clone () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbTransaction BeginDbTransaction (IsolationLevel isolationLevel) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbCommand CreateDbCommand () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Open () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DataTable GetSchema () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DataTable GetSchema (String collectionName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DataTable GetSchema (String collectionName, string [] restrictionValues) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void ChangePassword (string connectionString, string newPassword) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void ClearAllPools () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void ClearPool (SqlConnection connection) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void ResetStatistics () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public IDictionary RetrieveStatistics () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlDataReader.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlDataReader.platformnotsupported.cs new file mode 100644 index 00000000000..395e97ac19e --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlDataReader.platformnotsupported.cs @@ -0,0 +1,363 @@ +// +// SqlDataReader.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Collections; +using System.Data.Common; +using System.Data.SqlClient; +using System.Data.SqlTypes; +using System.Data; +using System.IO; +using System.Threading.Tasks; +using System.Threading; +using System.Xml; + + +namespace System.Data.SqlClient +{ + public class SqlDataReader : DbDataReader , IDataReader, IDisposable, IDataRecord + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlDataReader is not supported on the current platform."; + + SqlDataReader () {} + + protected bool IsCommandBehavior (CommandBehavior condition) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Close () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool GetBoolean (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override byte GetByte (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override long GetBytes (int i, long dataIndex, byte [] buffer, int bufferIndex, int length) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override char GetChar (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override long GetChars (int i, long dataIndex, char [] buffer, int bufferIndex, int length) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string GetDataTypeName (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DateTime GetDateTime (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual DateTimeOffset GetDateTimeOffset (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual TimeSpan GetTimeSpan (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlChars GetSqlChars (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Decimal GetDecimal (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Double GetDouble (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Type GetFieldType (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Single GetFloat (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Guid GetGuid (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override short GetInt16 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int GetInt32 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override long GetInt64 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string GetName (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int GetOrdinal (string name) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DataTable GetSchemaTable () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlBinary GetSqlBinary (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlBoolean GetSqlBoolean (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlByte GetSqlByte (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlDateTime GetSqlDateTime (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlDecimal GetSqlDecimal (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlDouble GetSqlDouble (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlGuid GetSqlGuid (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlInt16 GetSqlInt16 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlInt32 GetSqlInt32 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlInt64 GetSqlInt64 (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlMoney GetSqlMoney (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlSingle GetSqlSingle (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlString GetSqlString (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlXml GetSqlXml (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual object GetSqlValue (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual int GetSqlValues (object [] values) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override string GetString (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override object GetValue (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int GetValues (object [] values) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override IEnumerator GetEnumerator () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool IsDBNull (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool NextResult () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool Read () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Type GetProviderSpecificFieldType (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override object GetProviderSpecificValue (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int GetProviderSpecificValues (object [] values) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual SqlBytes GetSqlBytes (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override T GetFieldValue (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual XmlReader GetXmlReader (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Task GetFieldValueAsync (int i, CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Stream GetStream (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override TextReader GetTextReader (int i) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override Task IsDBNullAsync (int i, CancellationToken cancellationToken) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int Depth { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int FieldCount { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsClosed { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override object this [int i] { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override object this [string name] { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int RecordsAffected { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool HasRows { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int VisibleFieldCount { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + protected SqlConnection Connection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlException.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlException.platformnotsupported.cs new file mode 100644 index 00000000000..24d102d76f6 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlException.platformnotsupported.cs @@ -0,0 +1,102 @@ +// +// SqlException.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Data.Common; +using System.Data.SqlClient; +using System.Runtime.Serialization; + +namespace System.Data.SqlClient +{ + public class SqlException : DbException + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlException is not supported on the current platform."; + + internal bool _doNotReconnect; + + static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion, SqlInternalConnectionTds internalConnection, Exception innerException = null) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion, Guid conId, Exception innerException = null) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + SqlException () {} + + public override void GetObjectData (SerializationInfo si, StreamingContext context) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public byte Class { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public Guid ClientConnectionId { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlErrorCollection Errors { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int LineNumber { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string Message { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int Number { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string Procedure { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string Server { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string Source { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public byte State { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlParameter.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlParameter.platformnotsupported.cs new file mode 100644 index 00000000000..79f6f95baed --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlParameter.platformnotsupported.cs @@ -0,0 +1,198 @@ +// +// SqlParameter.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Data; +using System.Data.Common; +using System.Data.SqlTypes; + +namespace System.Data.SqlClient +{ + public class SqlParameter : DbParameter , IDbDataParameter, IDataParameter, ICloneable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlParameter is not supported on the current platform."; + + public SqlParameter () + : this (String.Empty, SqlDbType.NVarChar, 0, ParameterDirection.Input, false, 0, 0, String.Empty, DataRowVersion.Current, null) + { + } + + public SqlParameter (string parameterName, object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter (string parameterName, SqlDbType dbType) + : this (parameterName, dbType, 0, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, null) + { + } + + public SqlParameter (string parameterName, SqlDbType dbType, int size) + : this (parameterName, dbType, size, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, null) + { + } + + public SqlParameter (string parameterName, SqlDbType dbType, int size, string sourceColumn) + : this (parameterName, dbType, size, ParameterDirection.Input, false, 0, 0, sourceColumn, DataRowVersion.Current, null) + { + } + + public SqlParameter (string parameterName, SqlDbType dbType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter (string parameterName, SqlDbType dbType, int size, ParameterDirection direction, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping, Object value, string xmlSchemaCollectionDatabase, string xmlSchemaCollectionOwningSchema, string xmlSchemaCollectionName) + : this (parameterName, dbType, size, direction, false, precision, scale, sourceColumn, sourceVersion, value) + { + } + + public override string ToString () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void ResetDbType () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void ResetSqlDbType () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override DbType DbType { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override ParameterDirection Direction { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsNullable { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int Offset { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string ParameterName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public byte Precision { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public byte Scale { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int Size { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override string SourceColumn { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override DataRowVersion SourceVersion { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlDbType SqlDbType { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override object Value { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlCompareOptions CompareInfo { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int LocaleId { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public object SqlValue { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool SourceColumnNullMapping { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string XmlSchemaCollectionDatabase { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string XmlSchemaCollectionName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string XmlSchemaCollectionOwningSchema { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string UdtTypeName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string TypeName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + object ICloneable.Clone () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlParameterCollection.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlParameterCollection.platformnotsupported.cs new file mode 100644 index 00000000000..cc3a6ab1537 --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlParameterCollection.platformnotsupported.cs @@ -0,0 +1,216 @@ +// +// SqlParameterCollection.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Collections; +using System.Data; +using System.Data.Common; +using System.Data.SqlClient; + +namespace System.Data.SqlClient +{ + public class SqlParameterCollection : DbParameterCollection , IDataParameterCollection, IList, ICollection, IEnumerable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlParameterCollection is not supported on the current platform."; + + SqlParameterCollection () {} + + protected override DbParameter GetParameter (int index) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override DbParameter GetParameter (string parameterName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void SetParameter (int index, DbParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void SetParameter (string parameterName, DbParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int Add (object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter Add (SqlParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter Add (string parameterName, object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter AddWithValue (string parameterName, object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter Add (string parameterName, SqlDbType sqlDbType) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter Add (string parameterName, SqlDbType sqlDbType, int size) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlParameter Add (string parameterName, SqlDbType sqlDbType, int size, string sourceColumn) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Clear () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool Contains (object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool Contains (string value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public bool Contains (SqlParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void CopyTo (Array array, int index) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override IEnumerator GetEnumerator () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int IndexOf (object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int IndexOf (string parameterName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public int IndexOf (SqlParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Insert (int index, object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void Insert (int index, SqlParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Remove (object value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void Remove (SqlParameter value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void RemoveAt (int index) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void RemoveAt (string parameterName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void AddRange (Array values) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void AddRange (SqlParameter [] values) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void CopyTo (SqlParameter [] array, int index) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int Count { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsFixedSize { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsReadOnly { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsSynchronized { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override object SyncRoot { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlParameter this [int index] { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public SqlParameter this [string parameterName] { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + } +} diff --git a/mcs/class/System.Data/System.Data.SqlClient/SqlTransaction.platformnotsupported.cs b/mcs/class/System.Data/System.Data.SqlClient/SqlTransaction.platformnotsupported.cs new file mode 100644 index 00000000000..880b740c48f --- /dev/null +++ b/mcs/class/System.Data/System.Data.SqlClient/SqlTransaction.platformnotsupported.cs @@ -0,0 +1,77 @@ +// +// SqlTransaction.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Data; +using System.Data.Common; +using System.Data.SqlClient; + +namespace System.Data.SqlClient +{ + public class SqlTransaction : DbTransaction , IDbTransaction, IDisposable + { + const string EXCEPTION_MESSAGE = "System.Data.SqlClient.SqlTransaction is not supported on the current platform."; + + SqlTransaction () {} + + public override void Commit () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void Dispose (bool disposing) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Rollback () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void Rollback (string transactionName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void Save (string savePointName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SqlConnection Connection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override IsolationLevel IsolationLevel { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + protected override DbConnection DbConnection { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + } +} diff --git a/mcs/class/System.Data/Test/System.Data.Common/DbDataAdapterTest.cs b/mcs/class/System.Data/Test/System.Data.Common/DbDataAdapterTest.cs index 3749af50912..a8974949973 100644 --- a/mcs/class/System.Data/Test/System.Data.Common/DbDataAdapterTest.cs +++ b/mcs/class/System.Data/Test/System.Data.Common/DbDataAdapterTest.cs @@ -96,10 +96,14 @@ namespace MonoTests.System.Data.Common try { da.AddToBatch (new SqlCommand ()); Assert.Fail ("#1"); +#if FEATURE_NO_BSD_SOCKETS + } catch (PlatformNotSupportedException) { +#else } catch (NotSupportedException ex) { Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); +#endif } } diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlBulkCopyTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlBulkCopyTest.cs index b65ba7abab6..4fbbbbefe4a 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlBulkCopyTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlBulkCopyTest.cs @@ -39,21 +39,33 @@ namespace MonoTests.System.Data.SqlClient { private const string testFailParamNameMessage = "We have to provide the same parameter name as in original .NET"; [Test] // .ctor(SqlConnection connection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull1 () { new SqlBulkCopy ((SqlConnection)null); } [Test] // .ctor(string connectionString) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull2 () { new SqlBulkCopy ((string)null); } [Test] // .ctor(SqlConnection connection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull3 () { try { @@ -65,7 +77,11 @@ namespace MonoTests.System.Data.SqlClient { } [Test] // .ctor(string connectionString) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull4 () { try { @@ -77,7 +93,11 @@ namespace MonoTests.System.Data.SqlClient { } [Test] // .ctor(string connectionString) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull5 () { try { @@ -89,7 +109,11 @@ namespace MonoTests.System.Data.SqlClient { } [Test] // .ctor(string connectionString) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#else [ExpectedException (typeof(ArgumentNullException))] +#endif public void ConstructorNotNull6 () { try { diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandBuilderTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandBuilderTest.cs index c2d788bd3f5..49abd6064dc 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandBuilderTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandBuilderTest.cs @@ -38,6 +38,9 @@ namespace MonoTests.System.Data.Odbc public class SqlCommandBuilderTest { [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CatalogLocationTest () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -47,6 +50,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CatalogLocation_Value_Invalid () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -82,6 +88,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CatalogSeparator () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -89,6 +98,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CatalogSeparator_Value_Invalid () { string [] separators = new string [] { @@ -118,6 +130,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConflictOptionTest () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -127,6 +142,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConflictOption_Value_Invalid () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -147,6 +165,9 @@ namespace MonoTests.System.Data.Odbc } [Test] // QuoteIdentifier (String) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuoteIdentifier () { SqlCommandBuilder cb; @@ -173,6 +194,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuoteIdentifier_PrefixSuffix_NoMatch () { SqlCommandBuilder cb; @@ -211,6 +235,9 @@ namespace MonoTests.System.Data.Odbc } [Test] // QuoteIdentifier (String) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuoteIdentifier_UnquotedIdentifier_Null () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -226,6 +253,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuotePrefix () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -240,6 +270,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuotePrefix_Value_Invalid () { string [] prefixes = new string [] { @@ -268,6 +301,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuoteSuffix () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -282,6 +318,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void QuoteSuffix_Value_Invalid () { string [] suffixes = new string [] { @@ -310,6 +349,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SchemaSeparator () { SqlCommandBuilder cb = new SqlCommandBuilder (); @@ -319,6 +361,9 @@ namespace MonoTests.System.Data.Odbc } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SchemaSeparator_Value_Invalid () { string [] separators = new string [] { diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandTest.cs index d02532a45d9..be36ba383c1 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlCommandTest.cs @@ -42,6 +42,9 @@ namespace MonoTests.System.Data.SqlClient const string COMMAND_TEXT = "SELECT * FROM Authors"; [Test] // SqlCommand () +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor1 () { SqlCommand cmd = new SqlCommand (); @@ -61,6 +64,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlCommand (string) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2 () { SqlCommand cmd = new SqlCommand (COMMAND_TEXT); @@ -95,6 +101,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlCommand (string, SqlConnection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor3 () { SqlConnection conn = new SqlConnection (); @@ -147,6 +156,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlCommand (string, SqlConnection, SqlTransaction) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor4 () { SqlConnection conn = new SqlConnection (); @@ -199,6 +211,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Clone () { SqlNotificationRequest notificationReq = new SqlNotificationRequest (); @@ -237,6 +252,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CommandText () { SqlCommand cmd = new SqlCommand (); @@ -251,6 +269,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CommandTimeout () { SqlCommand cmd = new SqlCommand (); @@ -263,6 +284,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CommandTimeout_Value_Negative () { SqlCommand cmd = new SqlCommand (); @@ -279,6 +303,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CommandType_Value_Invalid () { SqlCommand cmd = new SqlCommand (); @@ -296,6 +323,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // bug #324386 +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Dispose () { string connectionString = "Initial Catalog=a;Server=b;User ID=c;" @@ -307,6 +337,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteNonQuery_Connection_Closed () { string connectionString = "Initial Catalog=a;Server=b;User ID=c;" @@ -329,6 +362,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteNonQuery_Connection_Null () { SqlCommand cmd = new SqlCommand ("delete from whatever"); @@ -346,6 +382,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteReader_Connection_Closed () { string connectionString = "Initial Catalog=a;Server=b;User ID=c;" @@ -368,6 +407,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteReader_Connection_Null () { SqlCommand cmd = new SqlCommand ("select * from whatever"); @@ -385,6 +427,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteScalar_Connection_Closed () { string connectionString = "Initial Catalog=a;Server=b;User ID=c;" @@ -407,6 +452,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // bug #412584 +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ExecuteScalar_Connection_Null () { SqlCommand cmd = new SqlCommand ("select count(*) from whatever"); @@ -425,6 +473,9 @@ namespace MonoTests.System.Data.SqlClient // FIXME: this actually doesn't match .NET behavior. It shouldn't throw NRE. [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Prepare_Connection_Null () { SqlCommand cmd; @@ -477,6 +528,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // bug #412586 +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Prepare_Connection_Closed () { string connectionString = "Initial Catalog=a;Server=b;User ID=c;" @@ -527,6 +581,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ResetCommandTimeout () { SqlCommand cmd = new SqlCommand (); @@ -537,6 +594,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void UpdatedRowSource () { SqlCommand cmd = new SqlCommand (); @@ -547,6 +607,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void UpdatedRowSource_Value_Invalid () { SqlCommand cmd = new SqlCommand (); @@ -565,6 +628,9 @@ namespace MonoTests.System.Data.SqlClient [Test] // bug #381100 +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ParameterCollectionTest () { SqlCommand cmd = new SqlCommand(); diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlConnectionTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlConnectionTest.cs index 04a4b99871c..9511be24f75 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlConnectionTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlConnectionTest.cs @@ -39,6 +39,9 @@ namespace MonoTests.System.Data.SqlClient public class SqlConnectionTest { [Test] // SqlConnection () +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor1 () { SqlConnection cn = new SqlConnection (); @@ -57,6 +60,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlConnection (string) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2 () { string connectionString = "server=SQLSRV; database=Mono;"; @@ -89,6 +95,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2_ConnectionString_Invalid () { try { @@ -181,6 +190,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void BeginTransaction_Connection_Closed () { SqlConnection cn = new SqlConnection (); @@ -247,6 +259,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangeDatabase_Connection_Closed () { SqlConnection cn = new SqlConnection (); @@ -264,6 +279,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangePassword_ConnectionString_Empty () { try { @@ -279,6 +297,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangePassword_ConnectionString_Null () { try { @@ -293,7 +314,10 @@ namespace MonoTests.System.Data.SqlClient } } - [Test] + +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangePassword_NewPassword_Empty () { try { @@ -309,6 +333,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangePassword_NewPassword_ExceedMaxLength () { try { @@ -328,6 +355,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ChangePassword_NewPassword_Null () { try { @@ -343,6 +373,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ClearPool_Connection_Null () { try { @@ -357,6 +390,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString () { SqlConnection cn = new SqlConnection (); @@ -371,6 +407,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_Value_Invalid () { SqlConnection cn = new SqlConnection (); @@ -403,6 +442,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CreateCommand () { SqlConnection cn = new SqlConnection (); @@ -424,6 +466,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Dispose () { SqlConnection cn = new SqlConnection ("Server=SQLSRV;Database=master;Timeout=25;Packet Size=512;Workstation ID=DUMMY"); @@ -443,6 +488,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void GetSchema_Connection_Closed () { SqlConnection cn = new SqlConnection (); @@ -519,6 +567,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_AsynchronousProcessing () { SqlConnection cn = new SqlConnection (); @@ -527,6 +578,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_ConnectTimeout () { SqlConnection cn = new SqlConnection (); @@ -543,6 +597,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_ConnectTimeout_Invalid () { SqlConnection cn = new SqlConnection (); @@ -600,6 +657,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_Database_Synonyms () { SqlConnection cn = null; @@ -614,6 +674,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_DataSource_Synonyms () { SqlConnection cn = null; @@ -640,6 +703,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MaxPoolSize () { SqlConnection cn = new SqlConnection (); @@ -649,6 +715,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MaxPoolSize_Invalid () { SqlConnection cn = new SqlConnection (); @@ -733,6 +802,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MinPoolSize () { SqlConnection cn = new SqlConnection (); @@ -742,6 +814,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MinPoolSize_Invalid () { SqlConnection cn = new SqlConnection (); @@ -799,6 +874,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MultipleActiveResultSets () { SqlConnection cn = new SqlConnection (); @@ -806,6 +884,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_MultipleActiveResultSets_Invalid () { SqlConnection cn = new SqlConnection (); @@ -823,6 +904,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_NetworkLibrary_Synonyms () { SqlConnection cn = new SqlConnection (); @@ -832,6 +916,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_PacketSize () { SqlConnection cn = new SqlConnection (); @@ -848,6 +935,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_PacketSize_Invalid () { SqlConnection cn = new SqlConnection (); @@ -901,6 +991,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_Password_Synonyms () { SqlConnection cn = new SqlConnection (); @@ -909,6 +1002,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_PersistSecurityInfo_Synonyms () { SqlConnection cn = new SqlConnection (); @@ -917,6 +1013,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_UserID_Synonyms () { SqlConnection cn = new SqlConnection (); @@ -926,6 +1025,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_UserInstance () { SqlConnection cn = new SqlConnection (); @@ -933,6 +1035,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_UserInstance_Invalid () { SqlConnection cn = new SqlConnection (); @@ -950,6 +1055,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ConnectionString_OtherKeywords () { SqlConnection cn = new SqlConnection (); @@ -973,6 +1081,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Open_ConnectionString_Empty () { SqlConnection cn = new SqlConnection (); @@ -991,6 +1102,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Open_ConnectionString_Null () { SqlConnection cn = new SqlConnection (); @@ -1009,6 +1123,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Open_ConnectionString_Whitespace () { SqlConnection cn = new SqlConnection (); @@ -1027,6 +1144,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ServerVersion_Connection_Closed () { SqlConnection cn = new SqlConnection (); @@ -1051,3 +1171,4 @@ namespace MonoTests.System.Data.SqlClient } } } + diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlDataAdapterTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlDataAdapterTest.cs index 301f62bf7f2..3a8b619baa1 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlDataAdapterTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlDataAdapterTest.cs @@ -63,6 +63,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (SqlCommand) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2 () { SqlCommand cmd = new SqlCommand (); @@ -109,6 +112,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, SqlConnection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor3 () { string selectCommandText = "SELECT * FROM Authors"; @@ -137,6 +143,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, SqlConnection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor3_SelectCommandText_Null () { SqlConnection selectConnection = new SqlConnection (); @@ -165,6 +174,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, SqlConnection) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor3_SelectConnection_Null () { string selectCommandText = "SELECT * FROM Authors"; @@ -192,6 +204,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, string)] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor4 () { string selectCommandText = "SELECT * FROM Authors"; @@ -221,6 +236,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, string)] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor4_SelectCommandText_Null () { string selectConnectionString = "server=SQLSRV;database=Mono"; @@ -250,6 +268,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // SqlDataAdapter (string, string)] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor4_SelectConnectionString_Null () { string selectCommandText = "SELECT * FROM Authors"; @@ -278,6 +299,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void DeleteCommand () { SqlDataAdapter da = new SqlDataAdapter (); @@ -293,6 +317,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Dispose () { SqlDataAdapter da = new SqlDataAdapter (); @@ -311,6 +338,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InsertCommand () { SqlDataAdapter da = new SqlDataAdapter (); @@ -326,6 +356,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SelectCommand () { SqlDataAdapter da = new SqlDataAdapter (); @@ -369,6 +402,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void UpdateCommand () { SqlDataAdapter da = new SqlDataAdapter (); diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs index 27e6fd1bf4a..e2048cfb9ba 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs @@ -45,6 +45,9 @@ namespace MonoTests.System.Data.SqlClient public class SqlParameterTest { [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor1 () { SqlParameter p = new SqlParameter (); @@ -68,6 +71,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2_Value_DateTime () { DateTime value = new DateTime (2004, 8, 24); @@ -94,6 +100,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2_Value_DBNull () { SqlParameter p = new SqlParameter ("address", DBNull.Value); @@ -118,6 +127,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor2_Value_Null () { SqlParameter p = new SqlParameter ("address", (Object) null); @@ -141,6 +153,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // .ctor (String, SqlDbType, Int32, ParameterDirection, Byte, Byte, String, DataRowVersion, Boolean, Object, String, String, String) +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Constructor7 () { SqlParameter p1 = new SqlParameter ("p1Name", SqlDbType.VarChar, 20, @@ -167,6 +182,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void CompareInfo () { SqlParameter parameter = new SqlParameter (); @@ -176,6 +194,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Byte () { Byte value = 0x0a; @@ -187,6 +208,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_ByteArray () { Byte [] value = new Byte [] { 0x0a, 0x0d }; @@ -289,6 +313,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_DateTime () { DateTime value; @@ -314,6 +341,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Decimal () { Decimal value; @@ -339,6 +369,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Double () { Double value; @@ -364,6 +397,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Enum () { SqlParameter param; @@ -380,6 +416,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Guid () { Guid value = Guid.NewGuid (); @@ -391,6 +430,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Int16 () { Int16 value; @@ -416,6 +458,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Int32 () { Int32 value; @@ -441,6 +486,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Int64 () { Int64 value; @@ -506,6 +554,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Object () { Object value = new Object (); @@ -517,6 +568,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Single () { Single value = Single.MaxValue; @@ -528,6 +582,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_String () { String value = "some text"; @@ -551,6 +608,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void LocaleId () { SqlParameter parameter = new SqlParameter (); @@ -560,6 +620,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] // bug #320196 +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ParameterNullTest () { SqlParameter param = new SqlParameter ("param", SqlDbType.Decimal); @@ -574,6 +637,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ParameterType () { SqlParameter p; @@ -632,6 +698,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void InferType_Boolean () { Boolean value; @@ -651,6 +720,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ParameterName () { SqlParameter p = new SqlParameter (); @@ -676,6 +748,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ResetDbType () { SqlParameter p; @@ -739,6 +814,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void ResetSqlDbType () { //Parameter with an assigned value but no SqlDbType specified @@ -779,6 +857,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SourceColumn () { SqlParameter p = new SqlParameter (); @@ -804,6 +885,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SourceColumnNullMapping () { SqlParameter p = new SqlParameter (); @@ -815,6 +899,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlDbTypeTest () { SqlParameter p = new SqlParameter ("zipcode", 3510); @@ -829,6 +916,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlDbTypeTest_Value_Invalid () { SqlParameter p = new SqlParameter ("zipcode", 3510); @@ -847,6 +937,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlValue () { SqlParameter parameter = new SqlParameter (); @@ -970,6 +1063,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlBinary () { SqlParameter parameter; @@ -995,6 +1091,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlBoolean () { SqlParameter parameter; @@ -1020,6 +1119,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlByte () { SqlParameter parameter; @@ -1107,6 +1209,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlDateTime () { SqlParameter parameter; @@ -1132,6 +1237,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlDecimal () { SqlParameter parameter; @@ -1157,6 +1265,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlDouble () { SqlParameter parameter; @@ -1182,6 +1293,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlGuid () { SqlParameter parameter; @@ -1207,6 +1321,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlInt16 () { SqlParameter parameter; @@ -1232,6 +1349,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlInt32 () { SqlParameter parameter; @@ -1257,6 +1377,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlInt64 () { SqlParameter parameter; @@ -1282,6 +1405,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlMoney () { SqlParameter parameter; @@ -1307,6 +1433,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlSingle () { SqlParameter parameter; @@ -1332,6 +1461,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlString () { SqlParameter parameter; @@ -1357,6 +1489,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SqlTypes_SqlXml () { SqlParameter parameter; @@ -1386,6 +1521,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void Value () { SqlParameter p; @@ -1429,6 +1567,9 @@ namespace MonoTests.System.Data.SqlClient } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void XmlSchemaTest () { SqlParameter p1 = new SqlParameter (); diff --git a/mcs/class/System.Data/monotouch_watch_System.Data.dll.exclude.sources b/mcs/class/System.Data/monotouch_watch_System.Data.dll.exclude.sources new file mode 100644 index 00000000000..2782624ebc8 --- /dev/null +++ b/mcs/class/System.Data/monotouch_watch_System.Data.dll.exclude.sources @@ -0,0 +1,11 @@ +System.Data.SqlClient/SqlBulkCopy.cs +System.Data.SqlClient/SqlCommand.cs +System.Data.SqlClient/SqlCommandBuilder.cs +System.Data.SqlClient/SqlConnection.cs +System.Data.SqlClient/SqlDataReader.cs +System.Data.SqlClient/SqlDecimalExtensions.cs +System.Data.SqlClient/SqlException.cs +System.Data.SqlClient/SqlParameter.cs +System.Data.SqlClient/SqlParameterCollection.cs +System.Data.SqlClient/SqlTransaction.cs +System.Data.SqlClient/SqlXmlTextReader.cs diff --git a/mcs/class/System.Data/monotouch_watch_System.Data.dll.sources b/mcs/class/System.Data/monotouch_watch_System.Data.dll.sources index bbc860b8cd7..f279aec8060 100644 --- a/mcs/class/System.Data/monotouch_watch_System.Data.dll.sources +++ b/mcs/class/System.Data/monotouch_watch_System.Data.dll.sources @@ -1 +1,10 @@ #include mobile_System.Data.dll.sources +System.Data.SqlClient/SqlBulkCopy.platformnotsupported.cs +System.Data.SqlClient/SqlCommand.platformnotsupported.cs +System.Data.SqlClient/SqlCommandBuilder.platformnotsupported.cs +System.Data.SqlClient/SqlConnection.platformnotsupported.cs +System.Data.SqlClient/SqlDataReader.platformnotsupported.cs +System.Data.SqlClient/SqlException.platformnotsupported.cs +System.Data.SqlClient/SqlParameter.platformnotsupported.cs +System.Data.SqlClient/SqlParameterCollection.platformnotsupported.cs +System.Data.SqlClient/SqlTransaction.platformnotsupported.cs diff --git a/mcs/class/System.IdentityModel/Makefile b/mcs/class/System.IdentityModel/Makefile index 7eea754cfa9..29bb7acd6ee 100644 --- a/mcs/class/System.IdentityModel/Makefile +++ b/mcs/class/System.IdentityModel/Makefile @@ -2,8 +2,12 @@ thisdir = class/System.IdentityModel SUBDIRS = include ../../build/rules.make +ifndef NO_MONO_SECURITY +MONO_SECURITY=Mono.Security +endif + LIBRARY = System.IdentityModel.dll -LIB_REFS = System System.Xml System.Security Mono.Security System.Runtime.Serialization +LIB_REFS = System System.Xml System.Security $(MONO_SECURITY) System.Runtime.Serialization LIB_MCS_FLAGS = \ /d:NET_3_0 \ $(OTHER_LIB_MCS_FLAGS) diff --git a/mcs/class/System.Security/Makefile b/mcs/class/System.Security/Makefile index 5c009acb566..145f30f4b6c 100644 --- a/mcs/class/System.Security/Makefile +++ b/mcs/class/System.Security/Makefile @@ -2,8 +2,13 @@ thisdir = class/System.Security SUBDIRS = include ../../build/rules.make +ifndef NO_MONO_SECURITY +MONO_SECURITY_DLL=$(the_libdir_base)/Mono.Security.dll +MONO_SECURITY=Mono.Security +endif + LIBRARY = System.Security.dll -LIB_REFS = secxml/System bare/System.Xml Mono.Security +LIB_REFS = secxml/System bare/System.Xml $(MONO_SECURITY) LIB_MCS_FLAGS = -nowarn:618 \ -d:SECURITY_DEP \ -nowarn:414 @@ -22,7 +27,7 @@ EXTRA_DISTFILES = \ include ../../build/library.make -$(build_lib): $(secxml_libdir)/System.dll $(the_libdir_base)/Mono.Security.dll +$(build_lib): $(secxml_libdir)/System.dll $(MONO_SECURITY_DLL) $(secxml_libdir)/System.dll: (cd ../System; $(MAKE) $@) diff --git a/mcs/class/System/Makefile b/mcs/class/System/Makefile index fe01d7e4317..fdfb7c293a4 100644 --- a/mcs/class/System/Makefile +++ b/mcs/class/System/Makefile @@ -19,10 +19,16 @@ TEST_RESOURCES = \ Test/System/test-uri-props-manual.txt \ Test/System/test-uri-relative-props.txt +ifndef NO_MONO_SECURITY +MONO_SECURITY=Mono.Security +MONO_SECURITY_REF=MonoSecurity=Mono.Security +MONO_SECURITY_DLL=$(the_libdir_base)Mono.Security.dll +endif + ifndef MOBILE_PROFILE -TEST_LIB_REFS = System.Drawing Mono.Security System.Data System.Xml System.Core System.Configuration +TEST_LIB_REFS = System.Drawing $(MONO_SECURITY) System.Data System.Xml System.Core System.Configuration else -TEST_LIB_REFS = Mono.Security System.Data System.Xml System.Core +TEST_LIB_REFS = $(MONO_SECURITY) System.Data System.Xml System.Core endif TEST_MCS_FLAGS = -nowarn:618,672,219,67,169,612 \ @@ -67,7 +73,7 @@ endif # ifeq (secxml/, $(intermediate)) LOCAL_MCS_FLAGS = -LIB_REFS += bare/System.Xml MonoSecurity=Mono.Security +LIB_REFS += bare/System.Xml $(MONO_SECURITY_REF) LIB_MCS_FLAGS += -d:SECURITY_DEP -d:XML_DEP $(EXTERN_ALIAS_FLAGS) endif @@ -75,7 +81,7 @@ endif # Flags used to build the final version of System (when intermediate is not defined) # ifndef intermediate -LIB_REFS += System.Xml MonoSecurity=Mono.Security +LIB_REFS += System.Xml $(MONO_SECURITY_REF) LIB_MCS_FLAGS += -d:SECURITY_DEP -d:XML_DEP $(EXTERN_ALIAS_FLAGS) ifndef MOBILE_PROFILE @@ -99,7 +105,7 @@ include ../../build/library.make system_library_deps := \ $(secxml_libdir)/System.dll \ $(the_libdir_base)System.Xml.dll \ - $(the_libdir_base)Mono.Security.dll \ + $(MONO_SECURITY_DLL) \ $(bare_libdir)/System.dll ifndef MOBILE_PROFILE @@ -108,7 +114,7 @@ endif artifacts = $(system_library_deps) \ $(bare_libdir)/System.Xml.dll \ - $(the_libdir_base)Mono.Security.dll \ + $(MONO_SECURITY_DLL) \ $(the_libdir_base)System.Configuration.dll .NOTPARALLEL: $(system_library_deps) @@ -123,7 +129,7 @@ $(bare_libdir)/System.dll: endif ifneq (secxml/,$(intermediate)) -$(secxml_libdir)/System.dll: $(bare_libdir)/System.dll $(bare_libdir)/System.Xml.dll $(the_libdir_base)Mono.Security.dll $(bare_libdir)/System.dll +$(secxml_libdir)/System.dll: $(bare_libdir)/System.dll $(bare_libdir)/System.Xml.dll $(MONO_SECURITY_DLL) $(bare_libdir)/System.dll $(MAKE) intermediate=secxml/ $(secxml_libdir)/System.dll else build-sec: diff --git a/mcs/class/System/System.Net.Security/SslStream.platformnotsupported.cs b/mcs/class/System/System.Net.Security/SslStream.platformnotsupported.cs new file mode 100644 index 00000000000..1d3f040c082 --- /dev/null +++ b/mcs/class/System/System.Net.Security/SslStream.platformnotsupported.cs @@ -0,0 +1,287 @@ +// +// SslStream.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.IO; +using System.Security.Authentication; +using System.Security.Cryptography.X509Certificates; +using System.Threading.Tasks; + +namespace System.Net.Security +{ + public class SslStream : AuthenticatedStream + { + const string EXCEPTION_MESSAGE = "System.Net.Security.SslStream is not supported on the current platform."; + + public SslStream (Stream innerStream) + : this (innerStream, false, null, null) + { + } + + public SslStream (Stream innerStream, bool leaveInnerStreamOpen) + : this (innerStream, leaveInnerStreamOpen, null, null) + { + } + + public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback) + : this (innerStream, leaveInnerStreamOpen, userCertificateValidationCallback, null) + { + } + + public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback) + : base (innerStream, leaveInnerStreamOpen) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback, EncryptionPolicy encryptionPolicy) + : this (innerStream, leaveInnerStreamOpen, userCertificateValidationCallback, userCertificateSelectionCallback) + { + } + + public virtual void AuthenticateAsClient (string targetHost) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual void AuthenticateAsClient (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual IAsyncResult BeginAuthenticateAsClient (string targetHost, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual IAsyncResult BeginAuthenticateAsClient (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual void EndAuthenticateAsClient (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual void AuthenticateAsServer (X509Certificate serverCertificate) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual void AuthenticateAsServer (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual IAsyncResult BeginAuthenticateAsServer (X509Certificate serverCertificate, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual IAsyncResult BeginAuthenticateAsServer (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual void EndAuthenticateAsServer (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public TransportContext TransportContext { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual Task AuthenticateAsClientAsync (string targetHost) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual Task AuthenticateAsClientAsync (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual Task AuthenticateAsServerAsync (X509Certificate serverCertificate) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public virtual Task AuthenticateAsServerAsync (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override bool IsAuthenticated { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsMutuallyAuthenticated { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsEncrypted { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsSigned { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool IsServer { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual SslProtocols SslProtocol { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual bool CheckCertRevocationStatus { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual X509Certificate LocalCertificate { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual X509Certificate RemoteCertificate { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual CipherAlgorithmType CipherAlgorithm { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual int CipherStrength { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual HashAlgorithmType HashAlgorithm { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual int HashStrength { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual ExchangeAlgorithmType KeyExchangeAlgorithm { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual int KeyExchangeStrength { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool CanSeek { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool CanRead { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool CanTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override bool CanWrite { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int ReadTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override int WriteTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override long Length { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override long Position { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public override void SetLength (long value) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override long Seek (long offset, SeekOrigin origin) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Flush () + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + protected override void Dispose (bool disposing) + { + } + + public override int Read (byte[] buffer, int offset, int count) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public void Write (byte[] buffer) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void Write (byte[] buffer, int offset, int count) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override IAsyncResult BeginRead (byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override int EndRead (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override IAsyncResult BeginWrite (byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public override void EndWrite (IAsyncResult asyncResult) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + } +} diff --git a/mcs/class/System/System.Net/AuthenticationManager.platformnotsupported.cs b/mcs/class/System/System.Net/AuthenticationManager.platformnotsupported.cs new file mode 100644 index 00000000000..1572ce7b575 --- /dev/null +++ b/mcs/class/System/System.Net/AuthenticationManager.platformnotsupported.cs @@ -0,0 +1,77 @@ +// +// AuthenticationManager.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Collections; +using System.Collections.Specialized; + +namespace System.Net +{ + public class AuthenticationManager { + const string EXCEPTION_MESSAGE = "System.Net.AuthenticationManager is not supported on the current platform."; + + private AuthenticationManager () + { + } + + public static ICredentialPolicy CredentialPolicy { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static StringDictionary CustomTargetNameDictionary { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static IEnumerator RegisteredModules { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static Authorization Authenticate (string challenge, WebRequest request, ICredentials credentials) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static Authorization PreAuthenticate (WebRequest request, ICredentials credentials) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void Register (IAuthenticationModule authenticationModule) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void Unregister (IAuthenticationModule authenticationModule) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static void Unregister (string authenticationScheme) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + } +} diff --git a/mcs/class/System/System.Net/HttpListener.platformnotsupported.cs b/mcs/class/System/System.Net/HttpListener.platformnotsupported.cs index b37b9d30bfb..bffdfbc7011 100644 --- a/mcs/class/System/System.Net/HttpListener.platformnotsupported.cs +++ b/mcs/class/System/System.Net/HttpListener.platformnotsupported.cs @@ -38,11 +38,6 @@ namespace System.Net { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - internal HttpListener (System.Security.Cryptography.X509Certificates.X509Certificate certificate, Mono.Net.Security.IMonoTlsProvider tlsProvider, Mono.Security.Interface.MonoTlsSettings tlsSettings) - { - throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); - } - public AuthenticationSchemes AuthenticationSchemes { get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } diff --git a/mcs/class/System/System.Net/HttpWebRequest.platformnotsupported.cs b/mcs/class/System/System.Net/HttpWebRequest.platformnotsupported.cs index 5fc016498d2..3977c7bad9c 100644 --- a/mcs/class/System/System.Net/HttpWebRequest.platformnotsupported.cs +++ b/mcs/class/System/System.Net/HttpWebRequest.platformnotsupported.cs @@ -38,11 +38,6 @@ namespace System.Net { internal const string EXCEPTION_MESSAGE = "System.Net.HttpWebRequest is not supported on the current platform."; - internal WebConnection WebConnection { - get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - } - #if MOBILE public #else @@ -96,14 +91,6 @@ namespace System.Net get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } } - internal Mono.Net.Security.IMonoTlsProvider TlsProvider { - get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - } - - internal Mono.Security.Interface.MonoTlsSettings TlsSettings { - get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - } - public X509CertificateCollection ClientCertificates { get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } @@ -431,30 +418,5 @@ namespace System.Net { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - - internal void SetWriteStream (WebConnectionStream stream) - { - throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); - } - - internal void SetResponseData (WebConnectionData data) - { - throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); - } - - internal void SetResponseError (WebExceptionStatus status, Exception e, string where) - { - throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); - } - - internal bool ReuseConnection { - get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - } - - internal WebConnection StoredConnection { - get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } - } } } diff --git a/mcs/class/System/System.Net/HttpWebResponse.platformnotsupported.cs b/mcs/class/System/System.Net/HttpWebResponse.platformnotsupported.cs index 1fd40a70f1a..300d5d4f607 100644 --- a/mcs/class/System/System.Net/HttpWebResponse.platformnotsupported.cs +++ b/mcs/class/System/System.Net/HttpWebResponse.platformnotsupported.cs @@ -36,11 +36,6 @@ namespace System.Net { const string EXCEPTION_MESSAGE = "System.Net.HttpWebResponse is not supported on the current platform."; - internal HttpWebResponse (Uri uri, string method, WebConnectionData data, CookieContainer container) - { - throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); - } - [Obsolete ("Serialization is obsoleted for this type", false)] protected HttpWebResponse (SerializationInfo serializationInfo, StreamingContext streamingContext) { diff --git a/mcs/class/System/System.Net/ServicePoint.platformnotsupported.cs b/mcs/class/System/System.Net/ServicePoint.platformnotsupported.cs new file mode 100644 index 00000000000..d744a556442 --- /dev/null +++ b/mcs/class/System/System.Net/ServicePoint.platformnotsupported.cs @@ -0,0 +1,127 @@ +// +// ServicePoint.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Net.Sockets; +using System.Security.Cryptography.X509Certificates; + +namespace System.Net +{ + public class ServicePoint + { + const string EXCEPTION_MESSAGE = "System.Net.ServicePoint is not supported on the current platform."; + + ServicePoint () {} + + public Uri Address { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + static Exception GetMustImplement () + { + return new NotImplementedException (); + } + + public BindIPEndPoint BindIPEndPointDelegate + { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int ConnectionLeaseTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int ConnectionLimit { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public string ConnectionName { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int CurrentConnections { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public DateTime IdleSince { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int MaxIdleTime { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public virtual Version ProtocolVersion { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public int ReceiveBufferSize { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool SupportsPipelining { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool Expect100Continue { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public bool UseNagleAlgorithm { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public void SetTcpKeepAlive (bool enabled, int keepAliveTime, int keepAliveInterval) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public bool CloseConnectionGroup (string connectionGroupName) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public X509Certificate Certificate { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public X509Certificate ClientCertificate { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + // For reference source + internal Socket GetConnection(PooledStream PooledStream, object owner, bool async, out IPAddress address, ref Socket abortSocket, ref Socket abortSocket6) + { + throw new NotImplementedException (); + } + } +} diff --git a/mcs/class/System/System.Net/ServicePointManager.platformnotsupported.cs b/mcs/class/System/System.Net/ServicePointManager.platformnotsupported.cs new file mode 100644 index 00000000000..2593b656fb0 --- /dev/null +++ b/mcs/class/System/System.Net/ServicePointManager.platformnotsupported.cs @@ -0,0 +1,129 @@ +// +// ServicePointManager.cs +// +// Author: +// Rolf Bjarne Kvinge +// +// Copyright (c) 2016 Xamarin, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System.Net.Security; + +namespace System.Net +{ + public partial class ServicePointManager { + const string EXCEPTION_MESSAGE = "System.Net.ServicePointManager is not supported on the current platform."; + + public const int DefaultNonPersistentConnectionLimit = 4; +#if MOBILE + public const int DefaultPersistentConnectionLimit = 10; +#else + public const int DefaultPersistentConnectionLimit = 2; +#endif + + private ServicePointManager () + { + } + + public static ICertificatePolicy CertificatePolicy { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static bool CheckCertificateRevocationList { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static int DefaultConnectionLimit { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static int DnsRefreshTimeout { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static bool EnableDnsRoundRobin { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static int MaxServicePointIdleTime { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static int MaxServicePoints { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static bool ReusePort { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static SecurityProtocolType SecurityProtocol { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static RemoteCertificateValidationCallback ServerCertificateValidationCallback { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static EncryptionPolicy EncryptionPolicy { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static bool Expect100Continue { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static bool UseNagleAlgorithm { + get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); } + } + + public static void SetTcpKeepAlive (bool enabled, int keepAliveTime, int keepAliveInterval) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static ServicePoint FindServicePoint (Uri address) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static ServicePoint FindServicePoint (string uriString, IWebProxy proxy) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + + public static ServicePoint FindServicePoint (Uri address, IWebProxy proxy) + { + throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); + } + } +} diff --git a/mcs/class/System/System.Security.Cryptography.X509Certificates/X509Helper2.cs b/mcs/class/System/System.Security.Cryptography.X509Certificates/X509Helper2.cs index 1dd6b2fdac1..337dcaf9ed2 100644 --- a/mcs/class/System/System.Security.Cryptography.X509Certificates/X509Helper2.cs +++ b/mcs/class/System/System.Security.Cryptography.X509Certificates/X509Helper2.cs @@ -34,11 +34,15 @@ extern alias MonoSecurity; #if MONO_SECURITY_ALIAS using MonoSecurity::Mono.Security.Interface; #else +#if !FEATURE_NO_BSD_SOCKETS using Mono.Security.Interface; #endif +#endif +#if !FEATURE_NO_BSD_SOCKETS using Mono.Btls; #endif +#endif using System.IO; using System.Text; @@ -88,6 +92,12 @@ namespace System.Security.Cryptography.X509Certificates X509Helper.ThrowIfContextInvalid (impl); } +#if FEATURE_NO_BSD_SOCKETS + static X509Certificate GetNativeInstance (X509CertificateImpl impl) + { + throw new PlatformNotSupportedException (); + } +#else static MonoBtlsX509 GetNativeInstance (X509CertificateImpl impl) { ThrowIfContextInvalid (impl); @@ -110,27 +120,31 @@ namespace System.Security.Cryptography.X509Certificates x509.ExportAsPEM (bio, includeHumanReadableForm); } } +#endif // !FEATURE_NO_BSD_SOCKETS internal static X509Certificate2Impl Import (byte[] rawData, string password, X509KeyStorageFlags keyStorageFlags) { +#if !FEATURE_NO_BSD_SOCKETS var provider = MonoTlsProviderFactory.GetProvider (); if (provider.HasNativeCertificates) { var impl = provider.GetNativeCertificate (rawData, password, keyStorageFlags); return impl; - } else { - var impl = new X509Certificate2ImplMono (); - impl.Import (rawData, password, keyStorageFlags); - return impl; } +#endif // FEATURE_NO_BSD_SOCKETS + var impl2 = new X509Certificate2ImplMono (); + impl2.Import (rawData, password, keyStorageFlags); + return impl2; } internal static X509Certificate2Impl Import (X509Certificate cert) { +#if !FEATURE_NO_BSD_SOCKETS var provider = MonoTlsProviderFactory.GetProvider (); if (provider.HasNativeCertificates) { var impl = provider.GetNativeCertificate (cert); return impl; } +#endif // FEATURE_NO_BSD_SOCKETS var impl2 = cert.Impl as X509Certificate2Impl; if (impl2 != null) return (X509Certificate2Impl)impl2.Clone (); diff --git a/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs b/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs index b0616ac7966..14ec2700869 100755 --- a/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs +++ b/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs @@ -2717,6 +2717,9 @@ namespace MonoTests.System.Net.Sockets } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (AggregateException))] // Something catches the PlatformNotSupportedException and re-throws an AggregateException +#endif public void ConcurrentExceedSocketLimit () { var tasks = new Task[4]; @@ -2727,6 +2730,9 @@ namespace MonoTests.System.Net.Sockets } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void SendGenericExceedBuffer () { // Create a buffer larger than the default max. diff --git a/mcs/class/System/Test/System.Net/ServicePointManagerTest.cs b/mcs/class/System/Test/System.Net/ServicePointManagerTest.cs index 8922c14f00e..b6808979e4a 100644 --- a/mcs/class/System/Test/System.Net/ServicePointManagerTest.cs +++ b/mcs/class/System/Test/System.Net/ServicePointManagerTest.cs @@ -29,8 +29,10 @@ public class ServicePointManagerTest [SetUp] public void GetReady () { +#if !FEATURE_NO_BSD_SOCKETS maxIdle = ServicePointManager.MaxServicePointIdleTime; ServicePointManager.MaxServicePointIdleTime = 10; +#endif googleUri = new Uri ("http://www.google.com"); yahooUri = new Uri ("http://www.yahoo.com"); apacheUri = new Uri ("http://www.apache.org"); @@ -39,7 +41,9 @@ public class ServicePointManagerTest [TearDown] public void Finish () { +#if !FEATURE_NO_BSD_SOCKETS ServicePointManager.MaxServicePointIdleTime = maxIdle; +#endif } [Test, ExpectedException (typeof (InvalidOperationException))] @@ -82,6 +86,9 @@ public class ServicePointManagerTest } [Test] +#if FEATURE_NO_BSD_SOCKETS + [ExpectedException (typeof (PlatformNotSupportedException))] +#endif public void FindServicePoint () { ServicePointManager.MaxServicePoints = 0; diff --git a/mcs/class/System/Test/System.Net/ServicePointTest.cs b/mcs/class/System/Test/System.Net/ServicePointTest.cs index 1e848148f92..6171a2fd255 100644 --- a/mcs/class/System/Test/System.Net/ServicePointTest.cs +++ b/mcs/class/System/Test/System.Net/ServicePointTest.cs @@ -23,6 +23,8 @@ namespace MonoTests.System.Net public class ServicePointTest { static private int max; + +#if !FEATURE_NO_BSD_SOCKETS [SetUp] public void SaveMax () { max = ServicePointManager.MaxServicePoints; @@ -33,6 +35,7 @@ public class ServicePointTest public void RestoreMax () { ServicePointManager.MaxServicePoints = max; } +#endif [Test] [Category ("InetAccess")] diff --git a/mcs/class/System/monotouch_watch_System.dll.exclude.sources b/mcs/class/System/monotouch_watch_System.dll.exclude.sources index 0138e11713a..384223cfee9 100644 --- a/mcs/class/System/monotouch_watch_System.dll.exclude.sources +++ b/mcs/class/System/monotouch_watch_System.dll.exclude.sources @@ -1,10 +1,119 @@ +../Mono.Security/Mono.Security.Authenticode/PrivateKey.cs +../Mono.Security/Mono.Security.Cryptography/MD5SHA1.cs +../Mono.Security/Mono.Security.Cryptography/TlsHMAC.cs +../Mono.Security/Mono.Security.Interface/Alert.cs +../Mono.Security/Mono.Security.Interface/CertificateValidationHelper.cs +../Mono.Security/Mono.Security.Interface/CipherAlgorithmType.cs +../Mono.Security/Mono.Security.Interface/CipherSuiteCode.cs +../Mono.Security/Mono.Security.Interface/ExchangeAlgorithmType.cs +../Mono.Security/Mono.Security.Interface/HashAlgorithmType.cs +../Mono.Security/Mono.Security.Interface/IBufferOffsetSize.cs +../Mono.Security/Mono.Security.Interface/IMonoSslStream.cs +../Mono.Security/Mono.Security.Interface/IMonoTlsContext.cs +../Mono.Security/Mono.Security.Interface/IMonoTlsEventSink.cs +../Mono.Security/Mono.Security.Interface/MonoTlsConnectionInfo.cs +../Mono.Security/Mono.Security.Interface/MonoTlsProvider.cs +../Mono.Security/Mono.Security.Interface/MonoTlsProviderFactory.Apple.cs +../Mono.Security/Mono.Security.Interface/MonoTlsProviderFactory.cs +../Mono.Security/Mono.Security.Interface/MonoTlsSettings.cs +../Mono.Security/Mono.Security.Interface/TlsException.cs +../Mono.Security/Mono.Security.Interface/TlsProtocolCode.cs +../Mono.Security/Mono.Security.Interface/TlsProtocols.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/ChallengeResponse.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/ChallengeResponse2.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/MessageBase.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/NtlmAuthLevel.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/NtlmFlags.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/NtlmSettings.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/Type1Message.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/Type2Message.cs +../Mono.Security/Mono.Security.Protocol.Ntlm/Type3Message.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsClientCertificate.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsClientCertificateVerify.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsClientFinished.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsClientHello.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsClientKeyExchange.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerCertificate.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerCertificateRequest.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerFinished.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerHello.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerHelloDone.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Client/TlsServerKeyExchange.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsClientCertificate.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsClientCertificateVerify.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsClientFinished.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsClientHello.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsClientKeyExchange.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerCertificate.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerCertificateRequest.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerFinished.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerHello.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerHelloDone.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake.Server/TlsServerKeyExchange.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake/ClientCertificateType.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake/HandshakeMessage.cs +../Mono.Security/Mono.Security.Protocol.Tls.Handshake/HandshakeType.cs +../Mono.Security/Mono.Security.Protocol.Tls/Alert.cs +../Mono.Security/Mono.Security.Protocol.Tls/CipherAlgorithmType.cs +../Mono.Security/Mono.Security.Protocol.Tls/CipherSuite.cs +../Mono.Security/Mono.Security.Protocol.Tls/CipherSuiteCollection.cs +../Mono.Security/Mono.Security.Protocol.Tls/CipherSuiteFactory.cs +../Mono.Security/Mono.Security.Protocol.Tls/ClientContext.cs +../Mono.Security/Mono.Security.Protocol.Tls/ClientRecordProtocol.cs +../Mono.Security/Mono.Security.Protocol.Tls/ClientSessionCache.cs +../Mono.Security/Mono.Security.Protocol.Tls/ContentType.cs +../Mono.Security/Mono.Security.Protocol.Tls/Context.cs +../Mono.Security/Mono.Security.Protocol.Tls/DebugHelper.cs +../Mono.Security/Mono.Security.Protocol.Tls/ExchangeAlgorithmType.cs +../Mono.Security/Mono.Security.Protocol.Tls/HandshakeState.cs +../Mono.Security/Mono.Security.Protocol.Tls/HashAlgorithmType.cs +../Mono.Security/Mono.Security.Protocol.Tls/HttpsClientStream.cs +../Mono.Security/Mono.Security.Protocol.Tls/RecordProtocol.cs +../Mono.Security/Mono.Security.Protocol.Tls/RSASslSignatureDeformatter.cs +../Mono.Security/Mono.Security.Protocol.Tls/RSASslSignatureFormatter.cs +../Mono.Security/Mono.Security.Protocol.Tls/SecurityCompressionType.cs +../Mono.Security/Mono.Security.Protocol.Tls/SecurityParameters.cs +../Mono.Security/Mono.Security.Protocol.Tls/SecurityProtocolType.cs +../Mono.Security/Mono.Security.Protocol.Tls/ServerContext.cs +../Mono.Security/Mono.Security.Protocol.Tls/ServerRecordProtocol.cs +../Mono.Security/Mono.Security.Protocol.Tls/SslCipherSuite.cs +../Mono.Security/Mono.Security.Protocol.Tls/SslClientStream.cs +../Mono.Security/Mono.Security.Protocol.Tls/SslHandshakeHash.cs +../Mono.Security/Mono.Security.Protocol.Tls/SslServerStream.cs +../Mono.Security/Mono.Security.Protocol.Tls/SslStreamBase.cs +../Mono.Security/Mono.Security.Protocol.Tls/TlsCipherSuite.cs +../Mono.Security/Mono.Security.Protocol.Tls/TlsClientSettings.cs +../Mono.Security/Mono.Security.Protocol.Tls/TlsException.cs +../Mono.Security/Mono.Security.Protocol.Tls/TlsServerSettings.cs +../Mono.Security/Mono.Security.Protocol.Tls/TlsStream.cs +Mono.Http/NtlmClient.cs +Mono.Net.Security/AsyncProtocolRequest.cs +Mono.Net.Security/CallbackHelpers.cs +Mono.Net.Security/ChainValidationHelper.cs +Mono.Net.Security/IMonoSslStream.cs +Mono.Net.Security/IMonoTlsProvider.cs Mono.Net.Security/LegacySslStream.cs +Mono.Net.Security/LegacySslStream.cs +Mono.Net.Security/LegacyTlsProvider.cs Mono.Net.Security/LegacyTlsProvider.cs +Mono.Net.Security/MobileAuthenticatedStream.cs +Mono.Net.Security/MobileTlsContext.cs +Mono.Net.Security/MonoSslStreamImpl.cs +Mono.Net.Security/MonoSslStreamWrapper.cs +Mono.Net.Security/MonoTlsProviderFactory.Apple.cs +Mono.Net.Security/MonoTlsProviderFactory.cs +Mono.Net.Security/MonoTlsProviderImpl.cs +Mono.Net.Security/MonoTlsProviderWrapper.cs +Mono.Net.Security/MonoTlsStream.cs +Mono.Net.Security/NoReflectionHelper.cs +Mono.Net.Security/SystemCertificateValidator.cs System.Net.Mail/SmtpClient.cs +System.Net.Security/SslStream.cs System.Net.Sockets/TcpClient.cs System.Net.Sockets/TcpListener.cs System.Net.Sockets/UdpClient.cs System.Net.WebSockets/ClientWebSocket.cs +System.Net/AuthenticationManager.cs System.Net/ChunkedInputStream.cs System.Net/EndPointListener.cs System.Net/EndPointManager.cs @@ -23,5 +132,51 @@ System.Net/HttpListenerRequest.cs System.Net/HttpListenerResponse.cs System.Net/HttpWebRequest.cs System.Net/HttpWebResponse.cs +System.Net/IWebConnectionState.cs System.Net/ListenerAsyncResult.cs +System.Net/NtlmClient.cs System.Net/ResponseStream.cs +System.Net/ServicePoint.cs +System.Net/ServicePointManager.cs +System.Net/WebConnection.cs +System.Net/WebConnectionData.cs +System.Net/WebConnectionGroup.cs +System.Net/WebConnectionStream.cs +Mono.Btls/MonoBtlsBio.cs +Mono.Btls/MonoBtlsContext.cs +Mono.Btls/MonoBtlsError.cs +Mono.Btls/MonoBtlsException.cs +Mono.Btls/MonoBtlsKey.cs +Mono.Btls/MonoBtlsObject.cs +Mono.Btls/MonoBtlsPkcs12.cs +Mono.Btls/MonoBtlsProvider.cs +Mono.Btls/MonoBtlsSsl.cs +Mono.Btls/MonoBtlsSslCtx.cs +Mono.Btls/MonoBtlsSslError.cs +Mono.Btls/MonoBtlsStream.cs +Mono.Btls/MonoBtlsUtils.cs +Mono.Btls/MonoBtlsX509.cs +Mono.Btls/MonoBtlsX509Chain.cs +Mono.Btls/MonoBtlsX509Crl.cs +Mono.Btls/MonoBtlsX509Error.cs +Mono.Btls/MonoBtlsX509Exception.cs +Mono.Btls/MonoBtlsX509FileType.cs +Mono.Btls/MonoBtlsX509Format.cs +Mono.Btls/MonoBtlsX509Lookup.cs +Mono.Btls/MonoBtlsX509LookupMonoCollection.cs +Mono.Btls/MonoBtlsX509LookupMono.cs +Mono.Btls/MonoBtlsX509LookupType.cs +Mono.Btls/MonoBtlsX509Name.cs +Mono.Btls/MonoBtlsX509NameList.cs +Mono.Btls/MonoBtlsX509NameEntryType.cs +Mono.Btls/MonoBtlsX509Purpose.cs +Mono.Btls/MonoBtlsX509Revoked.cs +Mono.Btls/MonoBtlsX509Store.cs +Mono.Btls/MonoBtlsX509StoreCtx.cs +Mono.Btls/MonoBtlsX509StoreManager.cs +Mono.Btls/MonoBtlsX509StoreType.cs +Mono.Btls/MonoBtlsX509TrustKind.cs +Mono.Btls/MonoBtlsX509VerifyFlags.cs +Mono.Btls/MonoBtlsX509VerifyParam.cs +Mono.Btls/X509CertificateImplBtls.cs +Mono.Btls/X509ChainImplBtls.cs diff --git a/mcs/class/System/monotouch_watch_System.dll.sources b/mcs/class/System/monotouch_watch_System.dll.sources index b606c440802..f7e73d81e36 100644 --- a/mcs/class/System/monotouch_watch_System.dll.sources +++ b/mcs/class/System/monotouch_watch_System.dll.sources @@ -1,9 +1,11 @@ #include monotouch_System.dll.sources System.Net.Mail/SmtpClient.platformnotsupported.cs +System.Net.Security/SslStream.platformnotsupported.cs System.Net.Sockets/TcpClient.platformnotsupported.cs System.Net.Sockets/TcpListener.platformnotsupported.cs System.Net.Sockets/UdpClient.platformnotsupported.cs System.Net.WebSockets/ClientWebSocket.platformnotsupported.cs +System.Net/AuthenticationManager.platformnotsupported.cs System.Net/FtpRequestCreator.platformnotsupported.cs System.Net/FtpWebRequest.platformnotsupported.cs System.Net/FtpWebResponse.platformnotsupported.cs @@ -14,3 +16,5 @@ System.Net/HttpListenerRequest.platformnotsupported.cs System.Net/HttpListenerResponse.platformnotsupported.cs System.Net/HttpWebRequest.platformnotsupported.cs System.Net/HttpWebResponse.platformnotsupported.cs +System.Net/ServicePoint.platformnotsupported.cs +System.Net/ServicePointManager.platformnotsupported.cs diff --git a/mcs/class/System/monotouch_watch_runtime_System.dll.exclude.sources b/mcs/class/System/monotouch_watch_runtime_System.dll.exclude.sources new file mode 100644 index 00000000000..8869410435c --- /dev/null +++ b/mcs/class/System/monotouch_watch_runtime_System.dll.exclude.sources @@ -0,0 +1 @@ +#include monotouch_watch_System.dll.exclude.sources diff --git a/mcs/class/System/monotouch_watch_runtime_System.dll.sources b/mcs/class/System/monotouch_watch_runtime_System.dll.sources index 7c0bd5983a5..c8c328c5ce6 100644 --- a/mcs/class/System/monotouch_watch_runtime_System.dll.sources +++ b/mcs/class/System/monotouch_watch_runtime_System.dll.sources @@ -1 +1 @@ -#include monotouch_System.dll.sources +#include monotouch_watch_System.dll.sources diff --git a/mcs/class/corlib/Assembly/AssemblyInfo.cs b/mcs/class/corlib/Assembly/AssemblyInfo.cs index d315128745d..6dc94160d19 100644 --- a/mcs/class/corlib/Assembly/AssemblyInfo.cs +++ b/mcs/class/corlib/Assembly/AssemblyInfo.cs @@ -83,6 +83,7 @@ using System.Runtime.InteropServices; [assembly: InternalsVisibleTo ("Xamarin.TVOS, PublicKey=0024000004800000940000000602000000240000525341310004000011000000438ac2a5acfbf16cbd2b2b47a62762f273df9cb2795ceccdf77d10bf508e69e7a362ea7a45455bbf3ac955e1f2e2814f144e5d817efc4c6502cc012df310783348304e3ae38573c6d658c234025821fda87a0be8a0d504df564e2c93b2b878925f42503e9d54dfef9f9586d9e6f38a305769587b1de01f6c0410328b2c9733db")] #elif MONOTOUCH_WATCH [assembly: InternalsVisibleTo ("Xamarin.WatchOS, PublicKey=0024000004800000940000000602000000240000525341310004000011000000438ac2a5acfbf16cbd2b2b47a62762f273df9cb2795ceccdf77d10bf508e69e7a362ea7a45455bbf3ac955e1f2e2814f144e5d817efc4c6502cc012df310783348304e3ae38573c6d658c234025821fda87a0be8a0d504df564e2c93b2b878925f42503e9d54dfef9f9586d9e6f38a305769587b1de01f6c0410328b2c9733db")] +[assembly: InternalsVisibleTo ("System.Security, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")] #else [assembly: InternalsVisibleTo ("monotouch, PublicKey=0024000004800000940000000602000000240000525341310004000011000000438ac2a5acfbf16cbd2b2b47a62762f273df9cb2795ceccdf77d10bf508e69e7a362ea7a45455bbf3ac955e1f2e2814f144e5d817efc4c6502cc012df310783348304e3ae38573c6d658c234025821fda87a0be8a0d504df564e2c93b2b878925f42503e9d54dfef9f9586d9e6f38a305769587b1de01f6c0410328b2c9733db")] [assembly: InternalsVisibleTo ("Xamarin.iOS, PublicKey=0024000004800000940000000602000000240000525341310004000011000000438ac2a5acfbf16cbd2b2b47a62762f273df9cb2795ceccdf77d10bf508e69e7a362ea7a45455bbf3ac955e1f2e2814f144e5d817efc4c6502cc012df310783348304e3ae38573c6d658c234025821fda87a0be8a0d504df564e2c93b2b878925f42503e9d54dfef9f9586d9e6f38a305769587b1de01f6c0410328b2c9733db")]