Loader: Remove unneeded load_pri declarations.
[asterisk/asterisk.git] / tests / test_sdp.c
index 38968aa..0ab8ec8 100644 (file)
@@ -29,6 +29,7 @@
 #include "asterisk/format.h"
 #include "asterisk/format_cache.h"
 #include "asterisk/format_cap.h"
+#include "asterisk/rtp_engine.h"
 
 static int validate_o_line(struct ast_test *test, const struct ast_sdp_o_line *o_line,
        const char *sdpowner, const char *address_type, const char *address)
@@ -87,13 +88,38 @@ static int validate_m_line(struct ast_test *test, const struct ast_sdp_m_line *m
                return -1;
        }
 
+       if (m_line->port == 0) {
+               ast_test_status_update(test, "Expected %s m-line to not be declined\n",
+                       media_type);
+               return -1;
+       }
+
        if (ast_sdp_m_get_payload_count(m_line) != num_payloads) {
-               ast_test_status_update(test, "Expected m-line payload count %d but got %d\n",
-                       num_payloads, ast_sdp_m_get_payload_count(m_line));
+               ast_test_status_update(test, "Expected %s m-line payload count %d but got %d\n",
+                       media_type, num_payloads, ast_sdp_m_get_payload_count(m_line));
+               return -1;
+       }
+
+       ast_test_status_update(test, "SDP %s m-line is as expected\n", media_type);
+       return 0;
+}
+
+static int validate_m_line_declined(struct ast_test *test,
+       const struct ast_sdp_m_line *m_line, const char *media_type)
+{
+       if (strcmp(m_line->type, media_type)) {
+               ast_test_status_update(test, "Expected m-line media type %s but got %s\n",
+                       media_type, m_line->type);
+               return -1;
+       }
+
+       if (m_line->port != 0) {
+               ast_test_status_update(test, "Expected %s m-line to be declined but got port %u\n",
+                       media_type, m_line->port);
                return -1;
        }
 
-       ast_test_status_update(test, "SDP m-line is as expected\n");
+       ast_test_status_update(test, "SDP %s m-line is as expected\n", media_type);
        return 0;
 }
 
@@ -130,6 +156,22 @@ static int validate_rtpmap(struct ast_test *test, const struct ast_sdp_m_line *m
        return -1;
 }
 
+static enum ast_test_result_state validate_t38(struct ast_test *test, const struct ast_sdp_m_line *m_line)
+{
+       struct ast_sdp_a_line *a_line;
+
+       a_line = ast_sdp_m_find_attribute(m_line, "T38FaxVersion", -1);
+       ast_test_validate(test, a_line && !strcmp(a_line->value, "0"));
+
+       a_line = ast_sdp_m_find_attribute(m_line, "T38FaxMaxBitRate", -1);
+       ast_test_validate(test, a_line && !strcmp(a_line->value, "14400"));
+
+       a_line = ast_sdp_m_find_attribute(m_line, "T38FaxRateManagement", -1);
+       ast_test_validate(test, a_line && !strcmp(a_line->value, "transferredTCF"));
+
+       return AST_TEST_PASS;
+}
+
 AST_TEST_DEFINE(invalid_rtpmap)
 {
        /* a=rtpmap: is already assumed. This is the part after that */
@@ -259,6 +301,7 @@ AST_TEST_DEFINE(find_attr)
        enum ast_test_result_state res = AST_TEST_PASS;
        struct ast_sdp_m_line *m_line;
        struct ast_sdp_a_line *a_line;
+       int idx;
 
        switch(cmd) {
        case TEST_INIT:
@@ -266,7 +309,7 @@ AST_TEST_DEFINE(find_attr)
                info->category = "/main/sdp/";
                info->summary = "Ensure that finding attributes works as expected";
                info->description =
-                       "An SDP m-line is created, and two attributes are added.\n"
+                       "A SDP m-line is created, and attributes are added.\n"
                        "We then attempt a series of attribute-finding calls that are expected to work\n"
                        "followed by a series of attribute-finding calls that are expected fo fail.";
                return AST_TEST_NOT_RUN;
@@ -285,6 +328,12 @@ AST_TEST_DEFINE(find_attr)
                goto end;
        }
        ast_sdp_m_add_a(m_line, a_line);
+       a_line = ast_sdp_a_alloc("foo", "0 bee");
+       if (!a_line) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       ast_sdp_m_add_a(m_line, a_line);
 
        a_line = ast_sdp_a_alloc("baz", "howdy");
        if (!a_line) {
@@ -295,21 +344,77 @@ AST_TEST_DEFINE(find_attr)
 
        /* These should work */
        a_line = ast_sdp_m_find_attribute(m_line, "foo", 0);
-       if (!a_line) {
+       if (!a_line || strcmp(a_line->value, "0 bar")) {
                ast_test_status_update(test, "Failed to find attribute 'foo' with payload '0'\n");
                res = AST_TEST_FAIL;
        }
        a_line = ast_sdp_m_find_attribute(m_line, "foo", -1);
-       if (!a_line) {
+       if (!a_line || strcmp(a_line->value, "0 bar")) {
                ast_test_status_update(test, "Failed to find attribute 'foo' with unspecified payload\n");
                res = AST_TEST_FAIL;
        }
        a_line = ast_sdp_m_find_attribute(m_line, "baz", -1);
-       if (!a_line) {
+       if (!a_line || strcmp(a_line->value, "howdy")) {
                ast_test_status_update(test, "Failed to find attribute 'baz' with unspecified payload\n");
                res = AST_TEST_FAIL;
        }
 
+       idx = ast_sdp_m_find_a_first(m_line, "foo", 0);
+       if (idx < 0) {
+               ast_test_status_update(test, "Failed to find first attribute 'foo' with payload '0'\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       a_line = ast_sdp_m_get_a(m_line, idx);
+       if (!a_line || strcmp(a_line->value, "0 bar")) {
+               ast_test_status_update(test, "Find first attribute 'foo' with payload '0' didn't match\n");
+               res = AST_TEST_FAIL;
+       }
+       idx = ast_sdp_m_find_a_next(m_line, idx, "foo", 0);
+       if (idx < 0) {
+               ast_test_status_update(test, "Failed to find next attribute 'foo' with payload '0'\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       a_line = ast_sdp_m_get_a(m_line, idx);
+       if (!a_line || strcmp(a_line->value, "0 bee")) {
+               ast_test_status_update(test, "Find next attribute 'foo' with payload '0' didn't match\n");
+               res = AST_TEST_FAIL;
+       }
+       idx = ast_sdp_m_find_a_next(m_line, idx, "foo", 0);
+       if (0 <= idx) {
+               ast_test_status_update(test, "Find next attribute 'foo' with payload '0' found too many\n");
+               res = AST_TEST_FAIL;
+       }
+
+       idx = ast_sdp_m_find_a_first(m_line, "foo", -1);
+       if (idx < 0) {
+               ast_test_status_update(test, "Failed to find first attribute 'foo' with unspecified payload\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       a_line = ast_sdp_m_get_a(m_line, idx);
+       if (!a_line || strcmp(a_line->value, "0 bar")) {
+               ast_test_status_update(test, "Find first attribute 'foo' with unspecified payload didn't match\n");
+               res = AST_TEST_FAIL;
+       }
+       idx = ast_sdp_m_find_a_next(m_line, idx, "foo", -1);
+       if (idx < 0) {
+               ast_test_status_update(test, "Failed to find next attribute 'foo' with unspecified payload\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       a_line = ast_sdp_m_get_a(m_line, idx);
+       if (!a_line || strcmp(a_line->value, "0 bee")) {
+               ast_test_status_update(test, "Find next attribute 'foo' with unspecified payload didn't match\n");
+               res = AST_TEST_FAIL;
+       }
+       idx = ast_sdp_m_find_a_next(m_line, idx, "foo", -1);
+       if (0 <= idx) {
+               ast_test_status_update(test, "Find next attribute 'foo' with unspecified payload found too many\n");
+               res = AST_TEST_FAIL;
+       }
+
        /* These should fail */
        a_line = ast_sdp_m_find_attribute(m_line, "foo", 1);
        if (a_line) {
@@ -328,7 +433,7 @@ AST_TEST_DEFINE(find_attr)
        }
        a_line = ast_sdp_m_find_attribute(m_line, "wibble", -1);
        if (a_line) {
-               ast_test_status_update(test, "Found non-existent attribute 'foo' with unspecified payload\n");
+               ast_test_status_update(test, "Found non-existent attribute 'wibble' with unspecified payload\n");
                res = AST_TEST_FAIL;
        }
 
@@ -337,26 +442,112 @@ end:
        return res;
 }
 
+static struct ast_sdp_options *sdp_options_common(void)
+{
+       struct ast_sdp_options *options;
+
+       options = ast_sdp_options_alloc();
+       if (!options) {
+               return NULL;
+       }
+       ast_sdp_options_set_media_address(options, "127.0.0.1");
+       ast_sdp_options_set_sdpowner(options, "me");
+       ast_sdp_options_set_rtp_engine(options, "asterisk");
+       ast_sdp_options_set_impl(options, AST_SDP_IMPL_PJMEDIA);
+
+       return options;
+}
+
 struct sdp_format {
        enum ast_media_type type;
        const char *formats;
 };
 
-static struct ast_sdp_state *build_sdp_state(int num_streams, const struct sdp_format *formats)
+static int build_sdp_option_formats(struct ast_sdp_options *options, int num_streams, const struct sdp_format *formats)
+{
+       int idx;
+
+       for (idx = 0; idx < num_streams; ++idx) {
+               struct ast_format_cap *caps;
+
+               if (ast_strlen_zero(formats[idx].formats)) {
+                       continue;
+               }
+
+               caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
+               if (!caps
+                       || ast_format_cap_update_by_allow_disallow(caps, formats[idx].formats, 1) < 0) {
+                       ao2_cleanup(caps);
+                       return -1;
+               }
+               ast_sdp_options_set_format_cap_type(options, formats[idx].type, caps);
+               ao2_cleanup(caps);
+       }
+       return 0;
+}
+
+/*!
+ * \brief Common method to build an SDP state for a test.
+ *
+ * This uses the passed-in formats to create a stream topology, which is then used to create the SDP
+ * state.
+ *
+ * There is an optional test_options field you can use if your test has specific options you need to
+ * set. If your test does not require anything special, it can just pass NULL for this parameter. If
+ * you do pass in test_options, this function steals ownership of those options.
+ *
+ * \param num_streams The number of elements in the formats array.
+ * \param formats Array of media types and formats that will be in the state.
+ * \param opt_num_streams The number of new stream types allowed to create.
+ *           Not used if test_options provided.
+ * \param opt_formats Array of new stream media types and formats allowed to create.
+ *           NULL if use a default stream creation.
+ *           Not used if test_options provided.
+ * \param max_streams 0 if set max to max(3, num_streams) else max(max_streams, num_streams)
+ *           Not used if test_options provided.
+ * \param test_options Optional SDP options.
+ */
+static struct ast_sdp_state *build_sdp_state(int num_streams, const struct sdp_format *formats,
+       int opt_num_streams, const struct sdp_format *opt_formats, unsigned int max_streams,
+       struct ast_sdp_options *test_options)
 {
        struct ast_stream_topology *topology = NULL;
        struct ast_sdp_state *state = NULL;
        struct ast_sdp_options *options;
        int i;
 
-       options = ast_sdp_options_alloc();
-       if (!options) {
-               goto end;
+       if (!test_options) {
+               static const struct sdp_format sdp_formats[] = {
+                       { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+                       { AST_MEDIA_TYPE_VIDEO, "vp8" },
+                       { AST_MEDIA_TYPE_IMAGE, "t38" },
+               };
+
+               options = sdp_options_common();
+               if (!options) {
+                       goto end;
+               }
+
+               /* Determine max_streams to allow */
+               if (!max_streams) {
+                       max_streams = ARRAY_LEN(sdp_formats);
+               }
+               if (max_streams < num_streams) {
+                       max_streams = num_streams;
+               }
+               ast_sdp_options_set_max_streams(options, max_streams);
+
+               /* Determine new stream formats and types allowed */
+               if (!opt_formats) {
+                       opt_num_streams = ARRAY_LEN(sdp_formats);
+                       opt_formats = sdp_formats;
+               }
+               if (build_sdp_option_formats(options, opt_num_streams, opt_formats)) {
+                       goto end;
+               }
+       } else {
+               options = test_options;
        }
-       ast_sdp_options_set_media_address(options, "127.0.0.1");
-       ast_sdp_options_set_sdpowner(options, "me");
-       ast_sdp_options_set_rtp_engine(options, "asterisk");
-       ast_sdp_options_set_impl(options, AST_SDP_IMPL_PJMEDIA);
 
        topology = ast_stream_topology_alloc();
        if (!topology) {
@@ -364,22 +555,31 @@ static struct ast_sdp_state *build_sdp_state(int num_streams, const struct sdp_f
        }
 
        for (i = 0; i < num_streams; ++i) {
-               RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
                struct ast_stream *stream;
 
-               caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
-               if (!caps) {
+               stream = ast_stream_alloc("sure_thing", formats[i].type);
+               if (!stream) {
                        goto end;
                }
-               if (ast_format_cap_update_by_allow_disallow(caps, formats[i].formats, 1) < 0) {
-                       goto end;
+               if (!ast_strlen_zero(formats[i].formats)) {
+                       struct ast_format_cap *caps;
+
+                       caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
+                       if (!caps
+                               || ast_format_cap_update_by_allow_disallow(caps, formats[i].formats, 1) < 0) {
+                               ao2_cleanup(caps);
+                               ast_stream_free(stream);
+                               goto end;
+                       }
+                       ast_stream_set_formats(stream, caps);
+                       ao2_cleanup(caps);
+               } else {
+                       ast_stream_set_state(stream, AST_STREAM_STATE_REMOVED);
                }
-               stream = ast_stream_alloc("sure_thing", formats[i].type);
-               if (!stream) {
+               if (ast_stream_topology_append_stream(topology, stream) < 0) {
+                       ast_stream_free(stream);
                        goto end;
                }
-               ast_stream_set_formats(stream, caps);
-               ast_stream_topology_append_stream(topology, stream);
        }
 
        state = ast_sdp_state_alloc(topology, options);
@@ -405,6 +605,7 @@ AST_TEST_DEFINE(topology_to_sdp)
        struct sdp_format formats[] = {
                { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
                { AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
        };
 
        switch(cmd) {
@@ -419,7 +620,8 @@ AST_TEST_DEFINE(topology_to_sdp)
                break;
        }
 
-       sdp_state = build_sdp_state(ARRAY_LEN(formats), formats);
+       sdp_state = build_sdp_state(ARRAY_LEN(formats), formats,
+               ARRAY_LEN(formats), formats, 0, NULL);
        if (!sdp_state) {
                goto end;
        }
@@ -437,7 +639,7 @@ AST_TEST_DEFINE(topology_to_sdp)
                goto end;
        }
 
-       if (ast_sdp_get_m_count(sdp) != 2) {
+       if (ast_sdp_get_m_count(sdp) != 3) {
                ast_test_status_update(test, "Unexpected number of streams in generated SDP: %d\n",
                        ast_sdp_get_m_count(sdp));
                goto end;
@@ -478,6 +680,14 @@ AST_TEST_DEFINE(topology_to_sdp)
                goto end;
        }
 
+       m_line = ast_sdp_get_m(sdp, 2);
+       if (validate_m_line(test, m_line, "image", 1)) {
+               goto end;
+       }
+       if (validate_t38(test, m_line) != AST_TEST_PASS) {
+               goto end;
+       }
+
        res = AST_TEST_PASS;
 
 end:
@@ -527,6 +737,7 @@ AST_TEST_DEFINE(sdp_to_topology)
        struct sdp_format sdp_formats[] = {
                { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
                { AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
        };
        static const char *expected_audio_formats[] = {
                "ulaw",
@@ -538,6 +749,9 @@ AST_TEST_DEFINE(sdp_to_topology)
                "h264",
                "vp8",
        };
+       static const char *expected_image_formats[] = {
+               "t38",
+       };
 
        switch(cmd) {
        case TEST_INIT:
@@ -551,7 +765,8 @@ AST_TEST_DEFINE(sdp_to_topology)
                break;
        }
 
-       sdp_state = build_sdp_state(ARRAY_LEN(sdp_formats), sdp_formats);
+       sdp_state = build_sdp_state(ARRAY_LEN(sdp_formats), sdp_formats,
+               ARRAY_LEN(sdp_formats), sdp_formats, 0, NULL);
        if (!sdp_state) {
                res = AST_TEST_FAIL;
                goto end;
@@ -563,10 +778,14 @@ AST_TEST_DEFINE(sdp_to_topology)
                goto end;
        }
 
-       topology = ast_get_topology_from_sdp(sdp);
+       topology = ast_get_topology_from_sdp(sdp, 0);
+       if (!topology) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
 
-       if (ast_stream_topology_get_count(topology) != 2) {
-               ast_test_status_update(test, "Unexpected topology count '%d'. Expecting 2\n",
+       if (ast_stream_topology_get_count(topology) != 3) {
+               ast_test_status_update(test, "Unexpected topology count '%d'. Expecting 3\n",
                        ast_stream_topology_get_count(topology));
                res = AST_TEST_FAIL;
                goto end;
@@ -584,13 +803,19 @@ AST_TEST_DEFINE(sdp_to_topology)
                goto end;
        }
 
+       if (validate_formats(test, topology, 2, AST_MEDIA_TYPE_IMAGE,
+                       ARRAY_LEN(expected_image_formats), expected_image_formats)) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+
 end:
        ast_sdp_state_free(sdp_state);
        ast_stream_topology_free(topology);
        return res;
 }
 
-static int validate_merged_sdp(struct ast_test *test, const struct ast_sdp *sdp)
+static int validate_avi_sdp_streams(struct ast_test *test, const struct ast_sdp *sdp)
 {
        struct ast_sdp_m_line *m_line;
 
@@ -599,11 +824,9 @@ static int validate_merged_sdp(struct ast_test *test, const struct ast_sdp *sdp)
        }
 
        m_line = ast_sdp_get_m(sdp, 0);
-
        if (validate_m_line(test, m_line, "audio", 1)) {
                return -1;
        }
-
        if (validate_rtpmap(test, m_line, "PCMU")) {
                return -1;
        }
@@ -612,33 +835,38 @@ static int validate_merged_sdp(struct ast_test *test, const struct ast_sdp *sdp)
        if (!validate_rtpmap(test, m_line, "PCMA")) {
                return -1;
        }
-
        if (!validate_rtpmap(test, m_line, "G722")) {
                return -1;
        }
-
        if (!validate_rtpmap(test, m_line, "opus")) {
                return -1;
        }
 
        m_line = ast_sdp_get_m(sdp, 1);
-
        if (validate_m_line(test, m_line, "video", 1)) {
                return -1;
        }
-
        if (validate_rtpmap(test, m_line, "VP8")) {
                return -1;
        }
-
        if (!validate_rtpmap(test, m_line, "H264")) {
                return -1;
        }
 
+       m_line = ast_sdp_get_m(sdp, 2);
+       if (validate_m_line(test, m_line, "image", 1)) {
+               return -1;
+       }
+
        return 0;
 }
 
-AST_TEST_DEFINE(sdp_merge_symmetric)
+static enum ast_test_result_state sdp_negotiation_completed_tests(struct ast_test *test,
+       int offer_num_streams, const struct sdp_format *offer_formats,
+       int answer_num_streams, const struct sdp_format *answer_formats,
+       int allowed_ans_num_streams, const struct sdp_format *allowed_ans_formats,
+       unsigned int max_streams,
+       int (*validate_sdp)(struct ast_test *test, const struct ast_sdp *sdp))
 {
        enum ast_test_result_state res = AST_TEST_PASS;
        struct ast_sdp_state *sdp_state_offerer = NULL;
@@ -646,63 +874,68 @@ AST_TEST_DEFINE(sdp_merge_symmetric)
        const struct ast_sdp *offerer_sdp;
        const struct ast_sdp *answerer_sdp;
 
-       static const struct sdp_format offerer_formats[] = {
-               { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
-               { AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
-       };
-       static const struct sdp_format answerer_formats[] = {
-               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
-               { AST_MEDIA_TYPE_VIDEO, "vp8" },
-       };
-
-       switch(cmd) {
-       case TEST_INIT:
-               info->name = "sdp_merge_symmetric";
-               info->category = "/main/sdp/";
-               info->summary = "Merge two SDPs with symmetric stream types";
-               info->description =
-                       "SDPs 1 and 2 each have one audio and one video stream (in that order).\n"
-                       "SDP 1 offers to SDP 2, who answers. We ensure that both local SDPs have\n"
-                       "the expected stream types and the expected formats";
-               return AST_TEST_NOT_RUN;
-       case TEST_EXECUTE:
-               break;
-       }
-
-       sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats);
+       sdp_state_offerer = build_sdp_state(offer_num_streams, offer_formats,
+               offer_num_streams, offer_formats, max_streams, NULL);
        if (!sdp_state_offerer) {
+               ast_test_status_update(test, "Building offerer SDP state failed\n");
                res = AST_TEST_FAIL;
                goto end;
        }
 
-       sdp_state_answerer = build_sdp_state(ARRAY_LEN(answerer_formats), answerer_formats);
+       sdp_state_answerer = build_sdp_state(answer_num_streams, answer_formats,
+               allowed_ans_num_streams, allowed_ans_formats, max_streams, NULL);
        if (!sdp_state_answerer) {
+               ast_test_status_update(test, "Building answerer SDP state failed\n");
                res = AST_TEST_FAIL;
                goto end;
        }
 
        offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
        if (!offerer_sdp) {
+               ast_test_status_update(test, "Building offerer offer failed\n");
                res = AST_TEST_FAIL;
                goto end;
        }
 
-       ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp);
+       if (ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp)) {
+               ast_test_status_update(test, "Setting answerer offer failed\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
        answerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_answerer);
        if (!answerer_sdp) {
+               ast_test_status_update(test, "Building answerer answer failed\n");
                res = AST_TEST_FAIL;
                goto end;
        }
 
-       ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp);
+       if (ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp)) {
+               ast_test_status_update(test, "Setting offerer answer failed\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
 
-       /* Get the offerer SDP again because it's now going to be the joint SDP */
+       /*
+        * Restart SDP negotiations to build the joint SDP on the offerer
+        * side.  Otherwise we will get the original offer for use in
+        * case of retransmissions.
+        */
+       if (ast_sdp_state_restart_negotiations(sdp_state_offerer)) {
+               ast_test_status_update(test, "Restarting negotiations failed\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
        offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
-       if (validate_merged_sdp(test, offerer_sdp)) {
+       if (!offerer_sdp) {
+               ast_test_status_update(test, "Building offerer current sdp failed\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       if (validate_sdp(test, offerer_sdp)) {
                res = AST_TEST_FAIL;
                goto end;
        }
-       if (validate_merged_sdp(test, answerer_sdp)) {
+       if (validate_sdp(test, answerer_sdp)) {
                res = AST_TEST_FAIL;
                goto end;
        }
@@ -714,81 +947,1122 @@ end:
        return res;
 }
 
-AST_TEST_DEFINE(sdp_merge_crisscross)
+AST_TEST_DEFINE(sdp_negotiation_initial)
 {
-       enum ast_test_result_state res = AST_TEST_PASS;
-       struct ast_sdp_state *sdp_state_offerer = NULL;
-       struct ast_sdp_state *sdp_state_answerer = NULL;
-       const struct ast_sdp *offerer_sdp;
-       const struct ast_sdp *answerer_sdp;
+       static const struct sdp_format offerer_formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
+               { AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
+       };
+
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_negotiation_initial";
+               info->category = "/main/sdp/";
+               info->summary = "Simulate an initial negotiation";
+               info->description =
+                       "Initial negotiation tests creating new streams on the answering side.\n"
+                       "After negotiation both offerer and answerer sides should have the same\n"
+                       "expected stream types and formats.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
 
+       return sdp_negotiation_completed_tests(test,
+               ARRAY_LEN(offerer_formats), offerer_formats,
+               0, NULL,
+               0, NULL,
+               0,
+               validate_avi_sdp_streams);
+}
+
+AST_TEST_DEFINE(sdp_negotiation_type_change)
+{
        static const struct sdp_format offerer_formats[] = {
                { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
                { AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
        };
        static const struct sdp_format answerer_formats[] = {
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
                { AST_MEDIA_TYPE_VIDEO, "vp8" },
                { AST_MEDIA_TYPE_AUDIO, "ulaw" },
        };
 
        switch(cmd) {
        case TEST_INIT:
-               info->name = "sdp_merge_crisscross";
+               info->name = "sdp_negotiation_type_change";
                info->category = "/main/sdp/";
-               info->summary = "Merge two SDPs with symmetric stream types";
+               info->summary = "Simulate a re-negotiation changing stream types";
                info->description =
-                       "SDPs 1 and 2 each have one audio and one video stream. However, SDP 1 and\n"
-                       "2 natively have the formats in a different order.\n"
-                       "SDP 1 offers to SDP 2, who answers. We ensure that both local SDPs have\n"
-                       "the expected stream types and the expected formats. Since SDP 1 was the\n"
-                       "offerer, the format order on SDP 1 should determine the order of formats in the SDPs";
+                       "Reinvite negotiation tests changing stream types on the answering side.\n"
+                       "After negotiation both offerer and answerer sides should have the same\n"
+                       "expected stream types and formats.";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
        }
 
-       sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats);
-       if (!sdp_state_offerer) {
-               res = AST_TEST_FAIL;
-               goto end;
+       return sdp_negotiation_completed_tests(test,
+               ARRAY_LEN(offerer_formats), offerer_formats,
+               ARRAY_LEN(answerer_formats), answerer_formats,
+               0, NULL,
+               0,
+               validate_avi_sdp_streams);
+}
+
+static int validate_aviavia_declined_sdp_streams(struct ast_test *test, const struct ast_sdp *sdp)
+{
+       struct ast_sdp_m_line *m_line;
+
+       if (!sdp) {
+               return -1;
        }
 
-       sdp_state_answerer = build_sdp_state(ARRAY_LEN(answerer_formats), answerer_formats);
-       if (!sdp_state_answerer) {
-               res = AST_TEST_FAIL;
-               goto end;
+       m_line = ast_sdp_get_m(sdp, 0);
+       if (validate_m_line_declined(test, m_line, "audio")) {
+               return -1;
        }
 
-       offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
-       if (!offerer_sdp) {
-               res = AST_TEST_FAIL;
-               goto end;
+       m_line = ast_sdp_get_m(sdp, 1);
+       if (validate_m_line_declined(test, m_line, "video")) {
+               return -1;
        }
 
-       ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp);
-       answerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_answerer);
-       if (!answerer_sdp) {
-               res = AST_TEST_FAIL;
-               goto end;
+       m_line = ast_sdp_get_m(sdp, 2);
+       if (validate_m_line_declined(test, m_line, "image")) {
+               return -1;
        }
 
-       ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp);
+       m_line = ast_sdp_get_m(sdp, 3);
+       if (validate_m_line_declined(test, m_line, "audio")) {
+               return -1;
+       }
 
-       /* Get the offerer SDP again because it's now going to be the joint SDP */
-       offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
-       if (validate_merged_sdp(test, offerer_sdp)) {
-               res = AST_TEST_FAIL;
-               goto end;
+       m_line = ast_sdp_get_m(sdp, 4);
+       if (validate_m_line_declined(test, m_line, "video")) {
+               return -1;
        }
-       if (validate_merged_sdp(test, answerer_sdp)) {
-               res = AST_TEST_FAIL;
-               goto end;
+
+       m_line = ast_sdp_get_m(sdp, 5);
+       if (validate_m_line_declined(test, m_line, "image")) {
+               return -1;
        }
 
-end:
-       ast_sdp_state_free(sdp_state_offerer);
-       ast_sdp_state_free(sdp_state_answerer);
+       m_line = ast_sdp_get_m(sdp, 6);
+       if (validate_m_line(test, m_line, "audio", 1)) {
+               return -1;
+       }
+       if (validate_rtpmap(test, m_line, "PCMU")) {
+               return -1;
+       }
+
+       /* The other audio formats should *NOT* be present */
+       if (!validate_rtpmap(test, m_line, "PCMA")) {
+               return -1;
+       }
+
+       return 0;
+}
+
+AST_TEST_DEFINE(sdp_negotiation_decline_incompatible)
+{
+       static const struct sdp_format offerer_formats[] = {
+               /* Incompatible declined streams */
+               { AST_MEDIA_TYPE_AUDIO, "alaw" },
+               { AST_MEDIA_TYPE_VIDEO, "vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
+               /* Initially declined streams */
+               { AST_MEDIA_TYPE_AUDIO, "" },
+               { AST_MEDIA_TYPE_VIDEO, "" },
+               { AST_MEDIA_TYPE_IMAGE, "" },
+               /* Compatible stream so not all are declined */
+               { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw" },
+       };
+       static const struct sdp_format allowed_formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+       };
 
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_negotiation_decline_incompatible";
+               info->category = "/main/sdp/";
+               info->summary = "Simulate an initial negotiation declining streams";
+               info->description =
+                       "Initial negotiation tests declining incompatible streams.\n"
+                       "After negotiation both offerer and answerer sides should have\n"
+                       "the same expected stream types and formats.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       return sdp_negotiation_completed_tests(test,
+               ARRAY_LEN(offerer_formats), offerer_formats,
+               0, NULL,
+               ARRAY_LEN(allowed_formats), allowed_formats,
+               ARRAY_LEN(offerer_formats),
+               validate_aviavia_declined_sdp_streams);
+}
+
+static int validate_aaaa_declined_sdp_streams(struct ast_test *test, const struct ast_sdp *sdp)
+{
+       struct ast_sdp_m_line *m_line;
+
+       if (!sdp) {
+               return -1;
+       }
+
+       m_line = ast_sdp_get_m(sdp, 0);
+       if (validate_m_line(test, m_line, "audio", 1)) {
+               return -1;
+       }
+       if (validate_rtpmap(test, m_line, "PCMU")) {
+               return -1;
+       }
+
+       m_line = ast_sdp_get_m(sdp, 1);
+       if (validate_m_line(test, m_line, "audio", 1)) {
+               return -1;
+       }
+       if (validate_rtpmap(test, m_line, "PCMU")) {
+               return -1;
+       }
+
+       m_line = ast_sdp_get_m(sdp, 2);
+       if (validate_m_line(test, m_line, "audio", 1)) {
+               return -1;
+       }
+       if (validate_rtpmap(test, m_line, "PCMU")) {
+               return -1;
+       }
+
+       m_line = ast_sdp_get_m(sdp, 3);
+       if (validate_m_line_declined(test, m_line, "audio")) {
+               return -1;
+       }
+
+       return 0;
+}
+
+AST_TEST_DEFINE(sdp_negotiation_decline_max_streams)
+{
+       static const struct sdp_format offerer_formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+               { AST_MEDIA_TYPE_AUDIO, "ulaw" },
+       };
+
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_negotiation_decline_max_streams";
+               info->category = "/main/sdp/";
+               info->summary = "Simulate an initial negotiation declining excessive streams";
+               info->description =
+                       "Initial negotiation tests declining too many streams on the answering side.\n"
+                       "After negotiation both offerer and answerer sides should have the same\n"
+                       "expected stream types and formats.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       return sdp_negotiation_completed_tests(test,
+               ARRAY_LEN(offerer_formats), offerer_formats,
+               0, NULL,
+               0, NULL,
+               0,
+               validate_aaaa_declined_sdp_streams);
+}
+
+AST_TEST_DEFINE(sdp_negotiation_not_acceptable)
+{
+       enum ast_test_result_state res = AST_TEST_PASS;
+       struct ast_sdp_state *sdp_state_offerer = NULL;
+       struct ast_sdp_state *sdp_state_answerer = NULL;
+       const struct ast_sdp *offerer_sdp;
+
+       static const struct sdp_format offerer_formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "alaw" },
+               { AST_MEDIA_TYPE_AUDIO, "alaw" },
+       };
+
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_negotiation_not_acceptable";
+               info->category = "/main/sdp/";
+               info->summary = "Simulate an initial negotiation declining all streams";
+               info->description =
+                       "Initial negotiation tests declining all streams for a 488 on the answering side.\n"
+                       "Negotiations should fail because there are no acceptable streams.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats,
+               ARRAY_LEN(offerer_formats), offerer_formats, 0, NULL);
+       if (!sdp_state_offerer) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+
+       sdp_state_answerer = build_sdp_state(0, NULL, 0, NULL, 0, NULL);
+       if (!sdp_state_answerer) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+
+       offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
+       if (!offerer_sdp) {
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+
+       if (!ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp)) {
+               ast_test_status_update(test, "Bad.  Setting remote SDP was successful.\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+       if (!ast_sdp_state_is_offer_rejected(sdp_state_answerer)) {
+               ast_test_status_update(test, "Bad.  Negotiation failed for some other reason.\n");
+               res = AST_TEST_FAIL;
+               goto end;
+       }
+
+end:
+       ast_sdp_state_free(sdp_state_offerer);
+       ast_sdp_state_free(sdp_state_answerer);
+
+       return res;
+}
+
+static int validate_ssrc(struct ast_test *test, struct ast_sdp_m_line *m_line,
+       struct ast_rtp_instance *rtp)
+{
+       unsigned int ssrc;
+       const char *cname;
+       struct ast_sdp_a_line *a_line;
+       char attr_value[128];
+
+       ssrc = ast_rtp_instance_get_ssrc(rtp);
+       cname = ast_rtp_instance_get_cname(rtp);
+
+       snprintf(attr_value, sizeof(attr_value), "%u cname:%s", ssrc, cname);
+
+       a_line = ast_sdp_m_find_attribute(m_line, "ssrc", -1);
+       if (!a_line) {
+               ast_test_status_update(test, "Could not find 'ssrc' attribute\n");
+               return -1;
+       }
+
+       if (strcmp(a_line->value, attr_value)) {
+               ast_test_status_update(test, "SDP attribute '%s' did not match expected attribute '%s'\n",
+                       a_line->value, attr_value);
+               return -1;
+       }
+
+       return 0;
+}
+
+AST_TEST_DEFINE(sdp_ssrc_attributes)
+{
+       enum ast_test_result_state res;
+       struct ast_sdp_state *test_state = NULL;
+       struct ast_sdp_options *options;
+       struct sdp_format formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
+       };
+       const struct ast_sdp *sdp;
+       struct ast_sdp_m_line *m_line;
+       struct ast_rtp_instance *rtp;
+
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_ssrc_attributes";
+               info->category = "/main/sdp/";
+               info->summary = "Ensure SSRC-level attributes are added to local SDPs";
+               info->description =
+                       "An SDP is created and is instructed to include SSRC-level attributes.\n"
+                       "This test ensures that the CNAME SSRC-level attribute is present and\n"
+                       "that the values match what the RTP instance reports";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       res = AST_TEST_FAIL;
+
+       options = sdp_options_common();
+       if (!options) {
+               ast_test_status_update(test, "Failed to allocate SDP options\n");
+               goto end;
+       }
+       if (build_sdp_option_formats(options, ARRAY_LEN(formats), formats)) {
+               goto end;
+       }
+       ast_sdp_options_set_ssrc(options, 1);
+
+       test_state = build_sdp_state(ARRAY_LEN(formats), formats, 0, NULL, 0, options);
+       if (!test_state) {
+               ast_test_status_update(test, "Failed to create SDP state\n");
+               goto end;
+       }
+
+       sdp = ast_sdp_state_get_local_sdp(test_state);
+       if (!sdp) {
+               ast_test_status_update(test, "Failed to get local SDP\n");
+               goto end;
+       }
+
+       /* Need a couple of sanity checks */
+       if (ast_sdp_get_m_count(sdp) != ARRAY_LEN(formats)) {
+               ast_test_status_update(test, "SDP m count is %d instead of %zu\n",
+                       ast_sdp_get_m_count(sdp), ARRAY_LEN(formats));
+               goto end;
+       }
+
+       m_line = ast_sdp_get_m(sdp, 0);
+       if (!m_line) {
+               ast_test_status_update(test, "Failed to get SDP m-line\n");
+               goto end;
+       }
+
+       rtp = ast_sdp_state_get_rtp_instance(test_state, 0);
+       if (!rtp) {
+               ast_test_status_update(test, "Failed to get the RTP instance\n");
+               goto end;
+       }
+
+       if (validate_ssrc(test, m_line, rtp)) {
+               goto end;
+       }
+
+       res = AST_TEST_PASS;
+
+end:
+       ast_sdp_state_free(test_state);
+       return res;
+}
+
+struct sdp_topology_stream {
+       /*! Media stream type: audio, video, image */
+       enum ast_media_type type;
+       /*! Media stream state: removed/declined, sendrecv */
+       enum ast_stream_state state;
+       /*! Comma separated list of formats allowed on the stream.  Can be NULL if stream is removed/declined. */
+       const char *formats;
+       /*! Optional name of stream.  NULL for default name. */
+       const char *name;
+};
+
+struct sdp_update_test {
+       /*! Maximum number of streams.  (0 if default) */
+       int max_streams;
+       /*! Optional initial SDP state topology (NULL if not present) */
+       const struct sdp_topology_stream * const *initial;
+       /*! Required first topology update */
+       const struct sdp_topology_stream * const *update_1;
+       /*! Optional second topology update (NULL if not present) */
+       const struct sdp_topology_stream * const *update_2;
+       /*! Expected topology to be offered */
+       const struct sdp_topology_stream * const *expected;
+};
+
+static struct ast_stream_topology *build_update_topology(const struct sdp_topology_stream * const *spec)
+{
+       struct ast_stream_topology *topology;
+       const struct sdp_topology_stream *desc;
+
+       topology = ast_stream_topology_alloc();
+       if (!topology) {
+               return NULL;
+       }
+
+       for (desc = *spec; desc; ++spec, desc = *spec) {
+               struct ast_stream *stream;
+               const char *name;
+
+               name = desc->name ?: ast_codec_media_type2str(desc->type);
+               stream = ast_stream_alloc(name, desc->type);
+               if (!stream) {
+                       goto fail;
+               }
+               ast_stream_set_state(stream, desc->state);
+               if (desc->formats) {
+                       struct ast_format_cap *caps;
+
+                       caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
+                       if (!caps
+                               || ast_format_cap_update_by_allow_disallow(caps, desc->formats, 1) < 0) {
+                               ao2_cleanup(caps);
+                               ast_stream_free(stream);
+                               goto fail;
+                       }
+                       ast_stream_set_formats(stream, caps);
+                       ao2_ref(caps, -1);
+               }
+               if (ast_stream_topology_append_stream(topology, stream) < 0) {
+                       ast_stream_free(stream);
+                       goto fail;
+               }
+       }
+       return topology;
+
+fail:
+       ast_stream_topology_free(topology);
+       return NULL;
+}
+
+static int cmp_update_topology(struct ast_test *test,
+       const struct ast_stream_topology *expected, const struct ast_stream_topology *merged)
+{
+       int status = 0;
+       int idx;
+       int max_streams;
+       struct ast_stream *exp_stream;
+       struct ast_stream *mrg_stream;
+
+       idx = ast_stream_topology_get_count(expected);
+       max_streams = ast_stream_topology_get_count(merged);
+       if (idx != max_streams) {
+               ast_test_status_update(test, "Expected %d streams got %d streams\n",
+                       idx, max_streams);
+               status = -1;
+       }
+       if (idx < max_streams) {
+               max_streams = idx;
+       }
+
+       /* Compare common streams by position */
+       for (idx = 0; idx < max_streams; ++idx) {
+               exp_stream = ast_stream_topology_get_stream(expected, idx);
+               mrg_stream = ast_stream_topology_get_stream(merged, idx);
+
+               if (strcmp(ast_stream_get_name(exp_stream), ast_stream_get_name(mrg_stream))) {
+                       ast_test_status_update(test,
+                               "Stream %d: Expected stream name '%s' got stream name '%s'\n",
+                               idx,
+                               ast_stream_get_name(exp_stream),
+                               ast_stream_get_name(mrg_stream));
+                       status = -1;
+               }
+
+               if (ast_stream_get_state(exp_stream) != ast_stream_get_state(mrg_stream)) {
+                       ast_test_status_update(test,
+                               "Stream %d: Expected stream state '%s' got stream state '%s'\n",
+                               idx,
+                               ast_stream_state2str(ast_stream_get_state(exp_stream)),
+                               ast_stream_state2str(ast_stream_get_state(mrg_stream)));
+                       status = -1;
+               }
+
+               if (ast_stream_get_type(exp_stream) != ast_stream_get_type(mrg_stream)) {
+                       ast_test_status_update(test,
+                               "Stream %d: Expected stream type '%s' got stream type '%s'\n",
+                               idx,
+                               ast_codec_media_type2str(ast_stream_get_type(exp_stream)),
+                               ast_codec_media_type2str(ast_stream_get_type(mrg_stream)));
+                       status = -1;
+                       continue;
+               }
+
+               if (ast_stream_get_state(exp_stream) == AST_STREAM_STATE_REMOVED
+                       || ast_stream_get_state(mrg_stream) == AST_STREAM_STATE_REMOVED) {
+                       /*
+                        * Cannot compare formats if one of the streams is
+                        * declined because there may not be any on the declined
+                        * stream.
+                        */
+                       continue;
+               }
+               if (!ast_format_cap_identical(ast_stream_get_formats(exp_stream),
+                       ast_stream_get_formats(mrg_stream))) {
+                       ast_test_status_update(test,
+                               "Stream %d: Expected formats do not match merged formats\n",
+                               idx);
+                       status = -1;
+               }
+       }
+
+       return status;
+}
+
+
+static const struct sdp_topology_stream audio_declined_no_name = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_REMOVED, NULL, NULL
+};
+
+static const struct sdp_topology_stream audio_ulaw_no_name = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "ulaw", NULL
+};
+
+static const struct sdp_topology_stream audio_alaw_no_name = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "alaw", NULL
+};
+
+static const struct sdp_topology_stream audio_g722_no_name = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "g722", NULL
+};
+
+static const struct sdp_topology_stream audio_g723_no_name = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "g723", NULL
+};
+
+static const struct sdp_topology_stream video_declined_no_name = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_REMOVED, NULL, NULL
+};
+
+static const struct sdp_topology_stream video_h261_no_name = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h261", NULL
+};
+
+static const struct sdp_topology_stream video_h263_no_name = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h263", NULL
+};
+
+static const struct sdp_topology_stream video_h264_no_name = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h264", NULL
+};
+
+static const struct sdp_topology_stream video_vp8_no_name = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "vp8", NULL
+};
+
+static const struct sdp_topology_stream image_declined_no_name = {
+       AST_MEDIA_TYPE_IMAGE, AST_STREAM_STATE_REMOVED, NULL, NULL
+};
+
+static const struct sdp_topology_stream image_t38_no_name = {
+       AST_MEDIA_TYPE_IMAGE, AST_STREAM_STATE_SENDRECV, "t38", NULL
+};
+
+
+static const struct sdp_topology_stream *top_ulaw_alaw_h264__vp8[] = {
+       &audio_ulaw_no_name,
+       &audio_alaw_no_name,
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top__vp8_alaw_h264_ulaw[] = {
+       &video_vp8_no_name,
+       &audio_alaw_no_name,
+       &video_h264_no_name,
+       &audio_ulaw_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_alaw_ulaw__vp8_h264[] = {
+       &audio_alaw_no_name,
+       &audio_ulaw_no_name,
+       &video_vp8_no_name,
+       &video_h264_no_name,
+       NULL
+};
+
+/* Sorting by type with no new or deleted streams */
+static const struct sdp_update_test mrg_by_type_00 = {
+       .initial  = top_ulaw_alaw_h264__vp8,
+       .update_1 = top__vp8_alaw_h264_ulaw,
+       .expected = top_alaw_ulaw__vp8_h264,
+};
+
+
+static const struct sdp_topology_stream *top_alaw__vp8[] = {
+       &audio_alaw_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_h264__vp8_ulaw[] = {
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       &audio_ulaw_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_ulaw_h264__vp8[] = {
+       &audio_ulaw_no_name,
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+/* Sorting by type and adding a stream */
+static const struct sdp_update_test mrg_by_type_01 = {
+       .initial  = top_alaw__vp8,
+       .update_1 = top_h264__vp8_ulaw,
+       .expected = top_ulaw_h264__vp8,
+};
+
+
+static const struct sdp_topology_stream *top_alaw__vp8_vdec[] = {
+       &audio_alaw_no_name,
+       &video_vp8_no_name,
+       &video_declined_no_name,
+       NULL
+};
+
+/* Sorting by type and deleting a stream */
+static const struct sdp_update_test mrg_by_type_02 = {
+       .initial  = top_ulaw_h264__vp8,
+       .update_1 = top_alaw__vp8,
+       .expected = top_alaw__vp8_vdec,
+};
+
+
+static const struct sdp_topology_stream *top_h264_alaw_ulaw[] = {
+       &video_h264_no_name,
+       &audio_alaw_no_name,
+       &audio_ulaw_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top__t38[] = {
+       &image_t38_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_vdec__t38_adec[] = {
+       &video_declined_no_name,
+       &image_t38_no_name,
+       &audio_declined_no_name,
+       NULL
+};
+
+/* Sorting by type changing stream types for T.38 */
+static const struct sdp_update_test mrg_by_type_03 = {
+       .initial  = top_h264_alaw_ulaw,
+       .update_1 = top__t38,
+       .expected = top_vdec__t38_adec,
+};
+
+
+/* Sorting by type changing stream types back from T.38 */
+static const struct sdp_update_test mrg_by_type_04 = {
+       .initial  = top_vdec__t38_adec,
+       .update_1 = top_h264_alaw_ulaw,
+       .expected = top_h264_alaw_ulaw,
+};
+
+
+static const struct sdp_topology_stream *top_h264[] = {
+       &video_h264_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_vdec__t38[] = {
+       &video_declined_no_name,
+       &image_t38_no_name,
+       NULL
+};
+
+/* Sorting by type changing stream types for T.38 */
+static const struct sdp_update_test mrg_by_type_05 = {
+       .initial  = top_h264,
+       .update_1 = top__t38,
+       .expected = top_vdec__t38,
+};
+
+
+static const struct sdp_topology_stream *top_h264_idec[] = {
+       &video_h264_no_name,
+       &image_declined_no_name,
+       NULL
+};
+
+/* Sorting by type changing stream types back from T.38 */
+static const struct sdp_update_test mrg_by_type_06 = {
+       .initial  = top_vdec__t38,
+       .update_1 = top_h264,
+       .expected = top_h264_idec,
+};
+
+
+static const struct sdp_topology_stream *top_ulaw_adec_h264__vp8[] = {
+       &audio_ulaw_no_name,
+       &audio_declined_no_name,
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_h263_alaw_h261_h264_vp8[] = {
+       &video_h263_no_name,
+       &audio_alaw_no_name,
+       &video_h261_no_name,
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_alaw_h264_h263_h261_vp8[] = {
+       &audio_alaw_no_name,
+       &video_h264_no_name,
+       &video_h263_no_name,
+       &video_h261_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+/* Sorting by type with backfill and adding streams */
+static const struct sdp_update_test mrg_by_type_07 = {
+       .initial  = top_ulaw_adec_h264__vp8,
+       .update_1 = top_h263_alaw_h261_h264_vp8,
+       .expected = top_alaw_h264_h263_h261_vp8,
+};
+
+
+static const struct sdp_topology_stream *top_ulaw_alaw_h264__vp8_h261[] = {
+       &audio_ulaw_no_name,
+       &audio_alaw_no_name,
+       &video_h264_no_name,
+       &video_vp8_no_name,
+       &video_h261_no_name,
+       NULL
+};
+
+/* Sorting by type overlimit of 4 and drop */
+static const struct sdp_update_test mrg_by_type_08 = {
+       .max_streams = 4,
+       .initial  = top_ulaw_alaw_h264__vp8,
+       .update_1 = top_ulaw_alaw_h264__vp8_h261,
+       .expected = top_ulaw_alaw_h264__vp8,
+};
+
+
+static const struct sdp_topology_stream *top_ulaw_alaw_h264[] = {
+       &audio_ulaw_no_name,
+       &audio_alaw_no_name,
+       &video_h264_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_alaw_h261__vp8[] = {
+       &audio_alaw_no_name,
+       &video_h261_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_alaw_adec_h261__vp8[] = {
+       &audio_alaw_no_name,
+       &audio_declined_no_name,
+       &video_h261_no_name,
+       &video_vp8_no_name,
+       NULL
+};
+
+/* Sorting by type with delete and add of streams */
+static const struct sdp_update_test mrg_by_type_09 = {
+       .initial  = top_ulaw_alaw_h264,
+       .update_1 = top_alaw_h261__vp8,
+       .expected = top_alaw_adec_h261__vp8,
+};
+
+
+static const struct sdp_topology_stream *top_ulaw_adec_h264[] = {
+       &audio_ulaw_no_name,
+       &audio_declined_no_name,
+       &video_h264_no_name,
+       NULL
+};
+
+/* Sorting by type and adding streams */
+static const struct sdp_update_test mrg_by_type_10 = {
+       .initial  = top_ulaw_adec_h264,
+       .update_1 = top_alaw_ulaw__vp8_h264,
+       .expected = top_alaw_ulaw__vp8_h264,
+};
+
+
+static const struct sdp_topology_stream *top_adec_g722_h261[] = {
+       &audio_declined_no_name,
+       &audio_g722_no_name,
+       &video_h261_no_name,
+       NULL
+};
+
+/* Sorting by type and deleting old streams */
+static const struct sdp_update_test mrg_by_type_11 = {
+       .initial  = top_ulaw_alaw_h264,
+       .update_1 = top_adec_g722_h261,
+       .expected = top_adec_g722_h261,
+};
+
+
+static const struct sdp_topology_stream audio_alaw4dave = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "alaw", "dave"
+};
+
+static const struct sdp_topology_stream audio_g7224dave = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "g722", "dave"
+};
+
+static const struct sdp_topology_stream audio_ulaw4fred = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "ulaw", "fred"
+};
+
+static const struct sdp_topology_stream audio_alaw4fred = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "alaw", "fred"
+};
+
+static const struct sdp_topology_stream audio_ulaw4rose = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "ulaw", "rose"
+};
+
+static const struct sdp_topology_stream audio_g7224rose = {
+       AST_MEDIA_TYPE_AUDIO, AST_STREAM_STATE_SENDRECV, "g722", "rose"
+};
+
+
+static const struct sdp_topology_stream video_h2614dave = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h261", "dave"
+};
+
+static const struct sdp_topology_stream video_h2634dave = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h263", "dave"
+};
+
+static const struct sdp_topology_stream video_h2634fred = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h263", "fred"
+};
+
+static const struct sdp_topology_stream video_h2644fred = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h264", "fred"
+};
+
+static const struct sdp_topology_stream video_h2644rose = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h264", "rose"
+};
+
+static const struct sdp_topology_stream video_h2614rose = {
+       AST_MEDIA_TYPE_VIDEO, AST_STREAM_STATE_SENDRECV, "h261", "rose"
+};
+
+
+static const struct sdp_topology_stream *top_adave_alaw_afred_ulaw_arose_g722_vdave_h261_vfred_h263_vrose_h264[] = {
+       &audio_alaw4dave,
+       &audio_alaw_no_name,
+       &audio_ulaw4fred,
+       &audio_ulaw_no_name,
+       &audio_g7224rose,
+       &audio_g722_no_name,
+       &video_h2614dave,
+       &video_h261_no_name,
+       &video_h2634fred,
+       &video_h263_no_name,
+       &video_h2644rose,
+       &video_h264_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_vfred_vrose_vdave_h263_h264_h261_afred_ulaw_arose_g722_adave_alaw[] = {
+       &video_h2644fred,
+       &video_h2614rose,
+       &video_h2634dave,
+       &video_h263_no_name,
+       &video_h264_no_name,
+       &video_h261_no_name,
+       &audio_alaw4fred,
+       &audio_ulaw_no_name,
+       &audio_ulaw4rose,
+       &audio_g722_no_name,
+       &audio_g7224dave,
+       &audio_alaw_no_name,
+       NULL
+};
+
+static const struct sdp_topology_stream *top_adave_ulaw_afred_g722_arose_alaw_vdave_h263_vfred_h264_vrose_h261[] = {
+       &audio_g7224dave,
+       &audio_ulaw_no_name,
+       &audio_alaw4fred,
+       &audio_g722_no_name,
+       &audio_ulaw4rose,
+       &audio_alaw_no_name,
+       &video_h2634dave,
+       &video_h263_no_name,
+       &video_h2644fred,
+       &video_h264_no_name,
+       &video_h2614rose,
+       &video_h261_no_name,
+       NULL
+};
+
+/* Sorting by name and type with no new or deleted streams */
+static const struct sdp_update_test mrg_by_name_00 = {
+       .initial  = top_adave_alaw_afred_ulaw_arose_g722_vdave_h261_vfred_h263_vrose_h264,
+       .update_1 = top_vfred_vrose_vdave_h263_h264_h261_afred_ulaw_arose_g722_adave_alaw,
+       .expected = top_adave_ulaw_afred_g722_arose_alaw_vdave_h263_vfred_h264_vrose_h261,
+};
+
+
+static const struct sdp_topology_stream *top_adave_g723_h261[] = {
+       &audio_g7224dave,
+       &audio_g723_no_name,
+       &video_h261_no_name,
+       NULL
+};
+
+/* Sorting by name and type adding names to streams */
+static const struct sdp_update_test mrg_by_name_01 = {
+       .initial  = top_ulaw_alaw_h264,
+       .update_1 = top_adave_g723_h261,
+       .expected = top_adave_g723_h261,
+};
+
+
+/* Sorting by name and type removing names from streams */
+static const struct sdp_update_test mrg_by_name_02 = {
+       .initial  = top_adave_g723_h261,
+       .update_1 = top_ulaw_alaw_h264,
+       .expected = top_ulaw_alaw_h264,
+};
+
+
+static const struct sdp_update_test *sdp_update_cases[] = {
+       /* Merging by type */
+       /* 00 */ &mrg_by_type_00,
+       /* 01 */ &mrg_by_type_01,
+       /* 02 */ &mrg_by_type_02,
+       /* 03 */ &mrg_by_type_03,
+       /* 04 */ &mrg_by_type_04,
+       /* 05 */ &mrg_by_type_05,
+       /* 06 */ &mrg_by_type_06,
+       /* 07 */ &mrg_by_type_07,
+       /* 08 */ &mrg_by_type_08,
+       /* 09 */ &mrg_by_type_09,
+       /* 10 */ &mrg_by_type_10,
+       /* 11 */ &mrg_by_type_11,
+
+       /* Merging by name and type */
+       /* 12 */ &mrg_by_name_00,
+       /* 13 */ &mrg_by_name_01,
+       /* 14 */ &mrg_by_name_02,
+};
+
+AST_TEST_DEFINE(sdp_update_topology)
+{
+       enum ast_test_result_state res;
+       unsigned int idx;
+       int status;
+       struct ast_sdp_options *options;
+       struct ast_stream_topology *topology;
+       struct ast_sdp_state *test_state = NULL;
+
+       static const struct sdp_format sdp_formats[] = {
+               { AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,g723" },
+               { AST_MEDIA_TYPE_VIDEO, "h261,h263,h264,vp8" },
+               { AST_MEDIA_TYPE_IMAGE, "t38" },
+       };
+
+       switch(cmd) {
+       case TEST_INIT:
+               info->name = "sdp_update_topology";
+               info->category = "/main/sdp/";
+               info->summary = "Merge topology updates from the system";
+               info->description =
+                       "1) Create a SDP state with an optional initial topology.\n"
+                       "2) Update the initial topology with one or two new topologies.\n"
+                       "3) Get the SDP offer to merge the updates into the initial topology.\n"
+                       "4) Check that the offered topology matches the expected topology.\n"
+                       "5) Repeat these steps for each test case defined.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       res = AST_TEST_FAIL;
+       for (idx = 0; idx < ARRAY_LEN(sdp_update_cases); ++idx) {
+               ast_test_status_update(test, "Starting update case %d\n", idx);
+
+               /* Create a SDP state with an optional initial topology. */
+               options = sdp_options_common();
+               if (!options) {
+                       ast_test_status_update(test, "Failed to allocate SDP options\n");
+                       goto end;
+               }
+               if (sdp_update_cases[idx]->max_streams) {
+                       ast_sdp_options_set_max_streams(options, sdp_update_cases[idx]->max_streams);
+               }
+               if (build_sdp_option_formats(options, ARRAY_LEN(sdp_formats), sdp_formats)) {
+                       ast_test_status_update(test, "Failed to setup SDP options new stream formats\n");
+                       goto end;
+               }
+               if (sdp_update_cases[idx]->initial) {
+                       topology = build_update_topology(sdp_update_cases[idx]->initial);
+                       if (!topology) {
+                               ast_test_status_update(test, "Failed to build initial SDP state topology\n");
+                               goto end;
+                       }
+               } else {
+                       topology = NULL;
+               }
+               test_state = ast_sdp_state_alloc(topology, options);
+               ast_stream_topology_free(topology);
+               if (!test_state) {
+                       ast_test_status_update(test, "Failed to build SDP state\n");
+                       goto end;
+               }
+
+               /* Update the initial topology with one or two new topologies. */
+               topology = build_update_topology(sdp_update_cases[idx]->update_1);
+               if (!topology) {
+                       ast_test_status_update(test, "Failed to build first update SDP state topology\n");
+                       goto end;
+               }
+               status = ast_sdp_state_update_local_topology(test_state, topology);
+               ast_stream_topology_free(topology);
+               if (status) {
+                       ast_test_status_update(test, "Failed to update first update SDP state topology\n");
+                       goto end;
+               }
+               if (sdp_update_cases[idx]->update_2) {
+                       topology = build_update_topology(sdp_update_cases[idx]->update_2);
+                       if (!topology) {
+                               ast_test_status_update(test, "Failed to build second update SDP state topology\n");
+                               goto end;
+                       }
+                       status = ast_sdp_state_update_local_topology(test_state, topology);
+                       ast_stream_topology_free(topology);
+                       if (status) {
+                               ast_test_status_update(test, "Failed to update second update SDP state topology\n");
+                               goto end;
+                       }
+               }
+
+               /* Get the SDP offer to merge the updates into the initial topology. */
+               if (!ast_sdp_state_get_local_sdp(test_state)) {
+                       ast_test_status_update(test, "Failed to create offer SDP\n");
+                       goto end;
+               }
+
+               /* Check that the offered topology matches the expected topology. */
+               topology = build_update_topology(sdp_update_cases[idx]->expected);
+               if (!topology) {
+                       ast_test_status_update(test, "Failed to build expected topology\n");
+                       goto end;
+               }
+               status = cmp_update_topology(test, topology,
+                       ast_sdp_state_get_local_topology(test_state));
+               ast_stream_topology_free(topology);
+               if (status) {
+                       ast_test_status_update(test, "Failed to match expected topology\n");
+                       goto end;
+               }
+
+               /* Repeat for each test case defined. */
+               ast_sdp_state_free(test_state);
+               test_state = NULL;
+       }
+       res = AST_TEST_PASS;
+
+end:
+       ast_sdp_state_free(test_state);
        return res;
 }
 
@@ -799,8 +2073,13 @@ static int unload_module(void)
        AST_TEST_UNREGISTER(find_attr);
        AST_TEST_UNREGISTER(topology_to_sdp);
        AST_TEST_UNREGISTER(sdp_to_topology);
-       AST_TEST_UNREGISTER(sdp_merge_symmetric);
-       AST_TEST_UNREGISTER(sdp_merge_crisscross);
+       AST_TEST_UNREGISTER(sdp_negotiation_initial);
+       AST_TEST_UNREGISTER(sdp_negotiation_type_change);
+       AST_TEST_UNREGISTER(sdp_negotiation_decline_incompatible);
+       AST_TEST_UNREGISTER(sdp_negotiation_decline_max_streams);
+       AST_TEST_UNREGISTER(sdp_negotiation_not_acceptable);
+       AST_TEST_UNREGISTER(sdp_ssrc_attributes);
+       AST_TEST_UNREGISTER(sdp_update_topology);
 
        return 0;
 }
@@ -812,8 +2091,13 @@ static int load_module(void)
        AST_TEST_REGISTER(find_attr);
        AST_TEST_REGISTER(topology_to_sdp);
        AST_TEST_REGISTER(sdp_to_topology);
-       AST_TEST_REGISTER(sdp_merge_symmetric);
-       AST_TEST_REGISTER(sdp_merge_crisscross);
+       AST_TEST_REGISTER(sdp_negotiation_initial);
+       AST_TEST_REGISTER(sdp_negotiation_type_change);
+       AST_TEST_REGISTER(sdp_negotiation_decline_incompatible);
+       AST_TEST_REGISTER(sdp_negotiation_decline_max_streams);
+       AST_TEST_REGISTER(sdp_negotiation_not_acceptable);
+       AST_TEST_REGISTER(sdp_ssrc_attributes);
+       AST_TEST_REGISTER(sdp_update_topology);
 
        return AST_MODULE_LOAD_SUCCESS;
 }