<!DOCTYPE html>
<title>drag &amp; drop - microdata with multiply named item as property</title>
<style>
  body > div {
    height: 200px;
    width: 200px;
    background-color: orange;
    position: absolute;
    top: 8px;
    left: 8px;
  }
  body > div * {
    display: none;
  }
  body > div + div {
    background-color: navy;
    left: 250px;
  }
  body > div + div + div {
    background-color: fuchsia;
    left: 500px;
  }
  p:first-of-type {
    margin-top: 220px;
  }
</style>

<script>

function makeEl(eltype,props,contents) {
	var elem = document.createElement(eltype);
	for( var i in props ) {
		if( props.hasOwnProperty(i) ) {
			elem.setAttribute(i,props[i]);
		}
	}
	if( contents ) {
		elem.innerHTML = contents;
	}
	return elem;
}

var orange, fails = [], doneonce = false;
window.onload = function() {
  orange = document.getElementsByTagName('div')[0];

	orange.appendChild( makeEl('div',{itemprop:'foo bar',itemscope:'itemscope'},'') );
	orange.lastChild.appendChild( makeEl('div',{itemprop:'baz'},'test') );

  orange.ondragstart = function(e) {
		e.dataTransfer.effectAllowed = 'copy';
    e.dataTransfer.setData('Text', 'dummy text');
  	var err;
		if( err = checkprops(e.dataTransfer.getData('application/microdata+json')) ) {
			fails[fails.length] = e.type + ' ' + err;
	  }
  };
  orange.nextSibling.ondragenter = orange.nextSibling.ondragleave = orange.nextSibling.ondragover =
  orange.ondrag = orange.ondragend = function(e) {
    if( e.type == 'dragover' || e.type == 'dragenter' ) {
    	e.preventDefault();
	    e.dataTransfer.dropEffect = 'copy';
    }
    if( e.dataTransfer.getData('application/microdata+json') ) {
			fails[fails.length] = e.type + ' unexpectedly had microdata (security restriction)';
    }
  };
	orange.nextSibling.ondrop = function(e) {
  	var err;
		if( err = checkprops(e.dataTransfer.getData('application/microdata+json')) ) {
			fails[fails.length] = e.type + ' ' + err;
	  }
	  if( e.type != 'drop' ) { return; }
  	if( doneonce ) { return; }
  	doneonce = true;
    setTimeout(function () {
    	document.getElementsByTagName('p')[0].innerHTML = fails.length ? ( 'FAIL: ' + fails.join('<br>') ) : 'PASS';
    	fails = [];
    }, 200 );
  };

};
function checkprops(md) {
	var i;
	if( !md ) { return 'no microdata'; }
	md = JSON.parse(md);
	if( !md.items ) { return 'no items'; }
	if( md.items.length != 1 ) { return md.items.length+' items instead of 1'; }
	if( !md.items[0].properties ) { return 'no properties'; }
	if( !md.items[0].properties.foo ) { return 'no properties.foo'; }
	if( !md.items[0].properties.bar ) { return 'no properties.bar'; }
	if( md.items[0].properties.baz ) { return 'properties.baz should not exist'; }
	if( md.items[0].properties.foo.length != 1 ) { return 'properties.foo length '+md.items[0].properties.foo.length+' instead of 1'; }
	if( md.items[0].properties.bar.length != 1 ) { return 'properties.bar length '+md.items[0].properties.bar.length+' instead of 1'; }

	if( !md.items[0].properties.foo[0] ) { return 'properties.foo[1] <i>'+md.items[0].properties.foo[0]+'</i> instead of <i>{properties:{baz:[test]}}</i>'; }
	if( !md.items[0].properties.foo[0].properties ) { return 'properties.foo[0].properties <i>'+md.items[0].properties.foo[0].properties+'</i> instead of <i>{baz:[test]}</i>'; }
	if( !md.items[0].properties.foo[0].properties.baz ) { return 'properties.foo[0].properties.baz <i>'+md.items[0].properties.foo[0].properties.baz+'</i> instead of <i>[test]</i>'; }
	if( !md.items[0].properties.foo[0].properties.baz.length ) { return 'properties.foo[0].properties.baz.length <i>'+md.items[0].properties.foo[0].properties.baz.length+'</i> instead of 1'; }
	if( md.items[0].properties.foo[0].properties.baz[0] != 'test') { return 'properties.foo[0].properties.baz[0] <i>'+md.items[0].properties.foo[0].properties.baz[0]+'</i> instead of <i>test</i>'; }

	if( !md.items[0].properties.bar[0] ) { return 'properties.bar[1] <i>'+md.items[0].properties.bar[0]+'</i> instead of <i>{properties:{baz:[test]}}</i>'; }
	if( !md.items[0].properties.bar[0].properties ) { return 'properties.bar[0].properties <i>'+md.items[0].properties.bar[0].properties+'</i> instead of <i>{baz:[test]}</i>'; }
	if( !md.items[0].properties.bar[0].properties.baz ) { return 'properties.bar[0].properties.baz <i>'+md.items[0].properties.bar[0].properties.baz+'</i> instead of <i>[test]</i>'; }
	if( !md.items[0].properties.bar[0].properties.baz.length ) { return 'properties.bar[0].properties.baz.length <i>'+md.items[0].properties.bar[0].properties.baz.length+'</i> instead of 1'; }
	if( md.items[0].properties.bar[0].properties.baz[0] != 'test') { return 'properties.bar[0].properties.baz[0] <i>'+md.items[0].properties.bar[0].properties.baz[0]+'</i> instead of <i>test</i>'; }

	return '';
}

</script>

<div draggable='true' itemscope></div><div></div><div></div>

<p>Use your pointing device to drag the orange box to the pink box, then back to the blue box, and release it.</p>
<noscript><p>Enable JavaScript and reload</p></noscript>
