You can use the same `ll` size modifier for `%x`, thus:

    #include &lt;stdio.h&gt;

    int main() {
        unsigned long long x = 123456789012345ULL;
        printf(&quot;%llx\n&quot;, x);
        return 0;
    }

The full range of conversion and formatting specifiers is in a great table here:

 * [`printf` documentation on cppeference.com](http://en.cppreference.com/w/c/io/fprintf)

try `%llu` - this will be long long unsigned in decimal form

`%llx` prints long long unsigned in hex

    printf(&quot;Hex add is: %llu&quot;, hexAdd);



I had a similar issue with this using the MinGW libraries. I couldn&#39;t get it to recognize the %llu or %llx stuff.

Here is my answer...

    void PutValue64(uint64_t value) {
    char	a_string[25];   // 16 for the hex data, 2 for the 0x, 1 for the term, and some spare
    uint32	MSB_part;
    uint32	LSB_part;
    
    	MSB_part = value &gt;&gt; 32;
    	LSB_part= value &amp; 0x00000000FFFFFFFF;
    
    	printf(a_string, &quot;0x%04x%08x&quot;, MSB_part, LSB_part);
    }

Note, I think the %04x can simply be %x, but the %08x is required.

Good luck.
Mark


How can I verify that a mocked method was not called at all - with any combination of parameters - using Mockito?

For example I have an object - `myObject` - that is using a second, mocked object - `myMockedOtherObject` - that has a method - `someMethodOrOther(String parameter1, String parameter2)`.

I want to call `myObject.myMethod()` and verify that `someMethodOrOther()` *doesn&#39;t* get called - with *any* combination of parameters.

e.g.:

    myObject.doSomeStuff();

    verify(myMockedOtherObject, never()).someMethodOrOther();

Except I can&#39;t do that, because `someMethodOrOther()` requires specific parameters to be supplied.

How to verify mocked method not called with any combination of parameters using Mockito

I was watching a youtube video and I decided to investigate some parts of its video player.  I noticed that unlike most HTML5 video I have seen, Youtube&#39;s video player does not do a normal video source and instead utilizes a blob url as the source.  

Previously I have tested HTML5 videos and I found that the server starts streaming the whole video from  the start and buffers in the background the complete rest of the video.  This means that if your video is 300 megs, all 300 megs will be downloaded.  If you seek to the middle, it will start downloading from the seek position all the way to the end.  

Youtube does not work this way (at least in chrome).  Instead it manages to control buffering so it only buffers a certain amount while paused. It also seems to only buffer the relevant pieces, so if you skip around it will make sure not to buffer pieces that are unlikely to be watched.

In my attempts to investigate how this worked, I noticed the video src tag has a value of `blob:http%3A//www.youtube.com/ee625eee-2802-49b2-a13f-eb374d551d54`, which pointed me to &lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/API/Blob&quot;&gt;blobs&lt;/a&gt;, which then led me to &lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data&quot;&gt;typed arrays&lt;/a&gt;.  Using those two resources I am able to load a mp4 video into a blob and display it in a HTML5 video tag.

However, what I am now stuck on is how Youtube deals with the pieces.  Looking at the network traffic it appears to sends requests to `http://r6---sn-p5q7ynee.c.youtube.com/videoplayback` which returns binary video data back in chunks of 1.1mb.  It also seems worth noting that most normal requests due to HTML5 video requests seem to receive a 206 response code back while it streams, yet youtube&#39;s playvideo calls get a 200 back.

I tried to attempt to only load a range of bytes (via setting the `Range` http header) which unfortunately failed (I&#39;m assuming because there was no meta-data for the video coming with the video).  

At this point I&#39;m stuck on figuring out how Youtube accomplishes this.  I came up with several ideas though none of which I am completely sold on:

1) Youtube is sending down self contained video and audio chunks with each `/videoplayback` call.  This seems like a pretty heavy burden on the upload side and it seems like it would be difficult to stitch these together to make it appear like it&#39;s one seemless video.  Also, the video tag seems to think it&#39;s one full video, judging from calling `$(&#39;video&#39;).duration` and `$(&#39;video&#39;).currentTime`, which leads me to believe that the video tag thinks it&#39;s a single video file.  Finally, the vidoe src tag never changes which makes me believe it is working with a singular blob and not switching out blobs.

2) Youtube constructs an empty blob pre-sized to the full video array and updates the blob with pieces as it downloads it.  It would then make sure the user has not gotten too close to the last downloaded piece (to prevent the user from entering an undownloaded section of the blob).  The problem that I see with this that I don&#39;t see any way to dynamically update a blob through javascript (although maybe I&#39;m just having trouble googling for it)

3) Youtube downloads the meta data and then starts constructing the blob in order by appending the video pieces as it downloads them.  The problem I see with this method is I don&#39;t understand how it would handle seeks in post-buffered territory.

Maybe I&quot;m just missing an obvious answer that&#39;s right in front of me.  Anyone have any ideas?


&lt;hr&gt;
&lt;b&gt;edit:&lt;b&gt; I just thought of a fourth option.  Another idea is they might use the file API to write the binary chunks to a file and use that file to stream off of.  The file API seems to have the ability to seek to specific positions, therefore allowing you to fill a video with empty bytes and fill them in as they are received.  This would definitely accommodate video seeking as well.

How does Youtube&#39;s HTML5 video player control buffering?

I am trying to print out an `unsigned long long` like this:

      printf(&quot;Hex add is: 0x%ux &quot;, hexAdd);


but I am getting type conversion errors since I have an `unsigned long long`.

unsigned long long type printing in hexadecimal format

I am trying to print out an <code>unsigned long long</code> like this:
<pre><code class="hljs language-perl"> printf("Hex add is: 0x%ux ", hexAdd);
</code></pre>
but I am getting type conversion errors since I have an <code>unsigned long long</code>.

Let:

    double d = 0.1;
    float f = 0.1;

should the expression

    (f &gt; d)

return `true` or `false`?

Empirically, the answer is `true`. However, I expected it to be `false`.  

As `0.1` cannot be perfectly represented in binary, while double has `15` to `16` decimal digits of precision, and float has only `7`. So, they both are less than `0.1`, while the double is more close to `0.1`.

I need an exact explanation for the `true`.

0.1 float is greater than 0.1 double. I expected it to be false

I read some legacy code:

    if ( 1 || !Foo() )

Is there any seen reason why not to write:

    if ( !Foo() )


Is there any reason for using if(1 || !Foo())?

From what i read there: https://stackoverflow.com/questions/2583766/why-is-objective-c-not-very-popular-outside-of-the-apple-community

&gt; Objective-C is a superset of C (much more strictly than C++, in fact) so the issue of backward compatibility does not arise. Anything you can do in C you can do in Objective-C.
&gt;
&gt; Being a superset is binary, like being pregnant. Obj-C is a superset of C, and C++ is not.

What do they mean by superset? In what way does objective-C would be more close//backward compatible to C? In what way does objective-C follow the C philosophy more closely than C++?

Can any C program be compiled without modification by a objective-C compiler (100% compatibility)?


This is more a question about programming language design and compatibility than a wars about which one is better.

What does &quot;Objective-C is a superset of C more strictly than C++&quot; mean exactly?

I know there are two different signatures to write the main method -

    int main()
    {
       //Code
    }

or for handling command line argument, we write it as-

    int main(int argc, char * argv[])
    {
       //code
    }

In `C++` I know we can overload a method, but in `C` how does the compiler handle these two different signatures of `main` function?

How does the main() method work in C?

I&#39;m trying to append the contents of a file myfile.txt to the end of a second file myfile2.txt in c. I can copy the contents, but I can&#39;t find a way to append. Here&#39;s my code:

    FILE *pFile;
    FILE *pFile2;
    char buffer[256];
    
    pFile=fopen(&quot;myfile.txt&quot;, &quot;r&quot;);
    pFile2=fopen(&quot;myfile2.txt&quot;, r+);
    if(pFile==NULL) {
        perror(&quot;Error opening file.&quot;);
    }
    else {
        while(!feof(pFile)) {
            if(fgets(buffer, 100, pFile) != NULL) {
            fseek(pFile2, -100, SEEK_END);
            fprintf(pFile2, buffer);
        }
    }
    fclose(pFile);
    fclose(pFile2);

I don&#39;t think I&#39;m using fseek correctly, but what I&#39;m trying to do is call fseek to put the pointer at the end of the file, then write at the location of that pointer, instead of at the beginning of the file. Is this the right approach?

Append to the end of a file in C

Can someone please explain to me what is going on here:

    char c = &#39;+&#39;;
    int i = (int)c;
    System.out.println(&quot;i: &quot; + i + &quot; ch: &quot; + Character.getNumericValue(c));

This prints `i: 43 ch:-1 `. Does that mean I have to rely on primitive conversions to convert `char` to `int`? So how can I convert a `Character` to `Integer`?

**Edit:** Yes I know `Character.getNumericValue` returns `-1` if it is not a numeric value and that makes sense to me. The question is: why does doing primitive conversions return `43`?

**Edit2:** `43` is the ASCII for `+`, but I would expect the cast to not succeed just like `getNumericValue` did not succeed. Otherwise that means there are two semantic equivalent ways to perform the same operation but with different results?

Converting characters to integers in Java

Is there any builtin function for PHP that will take a boolean value and return its integer equivalent? 0 for FALSE, 1 for TRUE?
Of course you can easily create a function to do so, I&#39;m just asking if there is a builtin function inside of PHP. I already tried `intval()` and casting it to `(int)` but they didnt work, they return 0 in both cases of TRUE and FALSE.

Edit : the problem was that it wasnt really a boolean, it was a string &quot;false&quot;, &quot;true&quot;, php didnt detect the jquery post that it passed a boolean. problem solved, thanks !

Convert boolean to integer value php

Let&#39;s say I have this number `i = -6884376`.
How do I refer to it as to an unsigned variable?
Something like `(unsigned long)i` in C.

How to convert signed to unsigned integer in python

Is there a way to convert `true` of type `unicode` to 1 and `false` of type `unicode` to 0 (in Python)?

For example: `x == &#39;true&#39; and type(x) == unicode`

I want `x = 1`

PS: I don’t want to use `if`-`else`.





How to convert &#39;false&#39; to 0 and &#39;true&#39; to 1?

I have no idea why these lines of code return different values:

    System.out.println(Integer.valueOf(&quot;127&quot;)==Integer.valueOf(&quot;127&quot;));
    System.out.println(Integer.valueOf(&quot;128&quot;)==Integer.valueOf(&quot;128&quot;));
    System.out.println(Integer.parseInt(&quot;128&quot;)==Integer.valueOf(&quot;128&quot;));

The output is:

    true
    false
    true

Why does the first one return `true` and the second one return `false`? Is there something different that I don&#39;t know between `127` and `128`? (Of course I know that `127` &lt; `128`.) 

Also, why does the third one return `true`?

I have read the answer [of this question](https://stackoverflow.com/questions/508665/difference-between-parseint-and-valueof-in-java ), but I still didn&#39;t get how it can return `true`, and why the code in second line returns `false`.


Why do == comparisons with Integer.valueOf(String) give different results for 127 and 128?

I&#39;m currently using a explicit cast to long and using `%ld` for printing `pid_t`, is there a specifier such as `%z` for `size_t` for `pid_t`?

If not what the best way of printing `pid_t`?


What is the correct printf specifier for printing pid_t

The output for this code printed out ‘Success’. 

    printf(&quot;%m\n&quot;);


What&#39;s the meaning of the %m formatting specifier?

I have this `printf` statement at the end of my program:

    printf(&quot;%d&quot;, total_candies);

`total_candies` is an `int`, and while I expect everything to work correctly, along with the actual number, I&#39;m getting a weird percent sign at the end.
![enter image description here][1]

Can anyone tell me why this is happening?

  [1]: http://i.stack.imgur.com/CwrDb.png

Getting a weird percent sign in printf output in terminal with C

I have this arduino sketch,

    char temperature[10];
    float temp = 10.55;
    sprintf(temperature,&quot;%f F&quot;, temp);
    Serial.println(temperature);

temperature prints out as

    ? F

Any thoughts on how to format this float? I need it to be a char string.


Arduino sprintf float not formatting

My code is:

    #include &lt;stdio.h&gt;
    #include &lt;string.h&gt;

    void main()
        {
	    char string[10];
	    int A = -73;
	    unsigned int B = 31337;

	    strcpy(string, &quot;sample&quot;);

	    // printing with different formats
	    printf(&quot;[A] Dec: %d, Hex: %x, Unsigned: %u\n&quot;, A,A,A);
	    printf(&quot;[B] Dec: %d, Hex: %x, Unsigned: %u\n&quot;, B,B,B);
	    printf(&quot;[field width on B] 3: &#39;%3u&#39;, 10: &#39;%10u&#39;, &#39;%08u&#39;\n&quot;, B,B,B);

	    // Example of unary address operator (dereferencing) and a %x
        // format string 
	    printf(&quot;variable A is at address: %08x\n&quot;, &amp;A);

I am using the terminal in linux mint to compile, and when I try to compile using gcc I get the following error message:

    basicStringFormatting.c: In function ‘main’:
    basicStringFormatting.c:18:2: warning: format ‘%x’ expects argument
    of type ‘unsigned int’, but argument 2 has type ‘int *’ [-Wformat=]
    printf(&quot;variable A is at address: %08x\n&quot;, &amp;A);

All I am trying to do is print the address in memory of the variable A.


Content Type	Original Author	Original Content on Stackoverflow
Question	Paul the Pirate	View Question on Stackoverflow
Solution 1 - C	gavinb	View Answer on Stackoverflow
Solution 2 - C	Iłya Bursov	View Answer on Stackoverflow
Solution 3 - C	Joseph	View Answer on Stackoverflow
Solution 4 - C	Cool Javelin	View Answer on Stackoverflow

unsigned long long type printing in hexadecimal format

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Solution 3 - C

Solution 4 - C

How does Youtube's HTML5 video player control buffering?

How to verify mocked method not called with any combination of parameters using Mockito

Attributions